Medusa Coverage Report GitHub

Files

    Files
    43
    Total Lines
    26271
    Coverage
    37.2%
    205 / 551 lines
    Actions
    33.3% lib/openzeppelin-contracts/contracts/access/Ownable.sol
    Lines covered: 5 / 15 (33.3%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {Context} from "../utils/Context.sol";
    7
    
                                                    
                                                
    8
    /**
    9
     * @dev Contract module which provides a basic access control mechanism, where
    10
     * there is an account (an owner) that can be granted exclusive access to
    11
     * specific functions.
    12
     *
    13
     * The initial owner is set to the address provided by the deployer. This can
    14
     * later be changed with {transferOwnership}.
    15
     *
    16
     * This module is used through inheritance. It will make available the modifier
    17
     * `onlyOwner`, which can be applied to your functions to restrict their use to
    18
     * the owner.
    19
     */
    20
    abstract contract Ownable is Context {
    21
        address private _owner;
    22
    
                                                    
                                                
    23
        /**
    24
         * @dev The caller account is not authorized to perform an operation.
    25
         */
    26
        error OwnableUnauthorizedAccount(address account);
    27
    
                                                    
                                                
    28
        /**
    29
         * @dev The owner is not a valid owner account. (eg. `address(0)`)
    30
         */
    31
        error OwnableInvalidOwner(address owner);
    32
    
                                                    
                                                
    33
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    34
    
                                                    
                                                
    35
        /**
    36
         * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
    37
         */
    38
        constructor(address initialOwner) {
    39
    ✓ 1
            if (initialOwner == address(0)) {
    40
                revert OwnableInvalidOwner(address(0));
    41
            }
    42
    ✓ 1
            _transferOwnership(initialOwner);
    43
        }
    44
    
                                                    
                                                
    45
        /**
    46
         * @dev Throws if called by any account other than the owner.
    47
         */
    48
        modifier onlyOwner() {
    49
            _checkOwner();
    50
            _;
    51
        }
    52
    
                                                    
                                                
    53
        /**
    54
         * @dev Returns the address of the current owner.
    55
         */
    56
        function owner() public view virtual returns (address) {
    57
            return _owner;
    58
        }
    59
    
                                                    
                                                
    60
        /**
    61
         * @dev Throws if the sender is not the owner.
    62
         */
    63
        function _checkOwner() internal view virtual {
    64
            if (owner() != _msgSender()) {
    65
                revert OwnableUnauthorizedAccount(_msgSender());
    66
            }
    67
        }
    68
    
                                                    
                                                
    69
        /**
    70
         * @dev Leaves the contract without owner. It will not be possible to call
    71
         * `onlyOwner` functions. Can only be called by the current owner.
    72
         *
    73
         * NOTE: Renouncing ownership will leave the contract without an owner,
    74
         * thereby disabling any functionality that is only available to the owner.
    75
         */
    76
        function renounceOwnership() public virtual onlyOwner {
    77
            _transferOwnership(address(0));
    78
        }
    79
    
                                                    
                                                
    80
        /**
    81
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
    82
         * Can only be called by the current owner.
    83
         */
    84
        function transferOwnership(address newOwner) public virtual onlyOwner {
    85
            if (newOwner == address(0)) {
    86
                revert OwnableInvalidOwner(address(0));
    87
            }
    88
            _transferOwnership(newOwner);
    89
        }
    90
    
                                                    
                                                
    91
        /**
    92
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
    93
         * Internal function without access restriction.
    94
         */
    95
        function _transferOwnership(address newOwner) internal virtual {
    96
    ✓ 1
            address oldOwner = _owner;
    97
    ✓ 1
            _owner = newOwner;
    98
    ✓ 1
            emit OwnershipTransferred(oldOwner, newOwner);
    99
        }
    100
    }
    101
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.6.2;
    5
    
                                                    
                                                
    6
    import {IERC20} from "./IERC20.sol";
    7
    import {IERC165} from "./IERC165.sol";
    8
    
                                                    
                                                
    9
    /**
    10
     * @title IERC1363
    11
     * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
    12
     *
    13
     * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
    14
     * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
    15
     */
    16
    interface IERC1363 is IERC20, IERC165 {
    17
        /*
    18
         * Note: the ERC-165 identifier for this interface is 0xb0202a11.
    19
         * 0xb0202a11 ===
    20
         *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
    21
         *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
    22
         *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
    23
         *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
    24
         *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
    25
         *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
    26
         */
    27
    
                                                    
                                                
    28
        /**
    29
         * @dev Moves a `value` amount of tokens from the caller's account to `to`
    30
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    31
         * @param to The address which you want to transfer to.
    32
         * @param value The amount of tokens to be transferred.
    33
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    34
         */
    35
        function transferAndCall(address to, uint256 value) external returns (bool);
    36
    
                                                    
                                                
    37
        /**
    38
         * @dev Moves a `value` amount of tokens from the caller's account to `to`
    39
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    40
         * @param to The address which you want to transfer to.
    41
         * @param value The amount of tokens to be transferred.
    42
         * @param data Additional data with no specified format, sent in call to `to`.
    43
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    44
         */
    45
        function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
    46
    
                                                    
                                                
    47
        /**
    48
         * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
    49
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    50
         * @param from The address which you want to send tokens from.
    51
         * @param to The address which you want to transfer to.
    52
         * @param value The amount of tokens to be transferred.
    53
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    54
         */
    55
        function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
    56
    
                                                    
                                                
    57
        /**
    58
         * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
    59
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    60
         * @param from The address which you want to send tokens from.
    61
         * @param to The address which you want to transfer to.
    62
         * @param value The amount of tokens to be transferred.
    63
         * @param data Additional data with no specified format, sent in call to `to`.
    64
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    65
         */
    66
        function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
    67
    
                                                    
                                                
    68
        /**
    69
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    70
         * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
    71
         * @param spender The address which will spend the funds.
    72
         * @param value The amount of tokens to be spent.
    73
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    74
         */
    75
        function approveAndCall(address spender, uint256 value) external returns (bool);
    76
    
                                                    
                                                
    77
        /**
    78
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    79
         * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
    80
         * @param spender The address which will spend the funds.
    81
         * @param value The amount of tokens to be spent.
    82
         * @param data Additional data with no specified format, sent in call to `spender`.
    83
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    84
         */
    85
        function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
    86
    }
    87
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.4.16;
    5
    
                                                    
                                                
    6
    import {IERC165} from "../utils/introspection/IERC165.sol";
    7
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.4.16;
    5
    
                                                    
                                                
    6
    import {IERC20} from "../token/ERC20/IERC20.sol";
    7
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC6093.sol)
    3
    pragma solidity >=0.8.4;
    4
    
                                                    
                                                
    5
    /**
    6
     * @dev Standard ERC-20 Errors
    7
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
    8
     */
    9
    interface IERC20Errors {
    10
        /**
    11
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    12
         * @param sender Address whose tokens are being transferred.
    13
         * @param balance Current balance for the interacting account.
    14
         * @param needed Minimum amount required to perform a transfer.
    15
         */
    16
        error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    17
    
                                                    
                                                
    18
        /**
    19
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    20
         * @param sender Address whose tokens are being transferred.
    21
         */
    22
        error ERC20InvalidSender(address sender);
    23
    
                                                    
                                                
    24
        /**
    25
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    26
         * @param receiver Address to which tokens are being transferred.
    27
         */
    28
        error ERC20InvalidReceiver(address receiver);
    29
    
                                                    
                                                
    30
        /**
    31
         * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
    32
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    33
         * @param allowance Amount of tokens a `spender` is allowed to operate with.
    34
         * @param needed Minimum amount required to perform a transfer.
    35
         */
    36
        error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    37
    
                                                    
                                                
    38
        /**
    39
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    40
         * @param approver Address initiating an approval operation.
    41
         */
    42
        error ERC20InvalidApprover(address approver);
    43
    
                                                    
                                                
    44
        /**
    45
         * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
    46
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    47
         */
    48
        error ERC20InvalidSpender(address spender);
    49
    }
    50
    
                                                    
                                                
    51
    /**
    52
     * @dev Standard ERC-721 Errors
    53
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
    54
     */
    55
    interface IERC721Errors {
    56
        /**
    57
         * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
    58
         * Used in balance queries.
    59
         * @param owner Address of the current owner of a token.
    60
         */
    61
        error ERC721InvalidOwner(address owner);
    62
    
                                                    
                                                
    63
        /**
    64
         * @dev Indicates a `tokenId` whose `owner` is the zero address.
    65
         * @param tokenId Identifier number of a token.
    66
         */
    67
        error ERC721NonexistentToken(uint256 tokenId);
    68
    
                                                    
                                                
    69
        /**
    70
         * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
    71
         * @param sender Address whose tokens are being transferred.
    72
         * @param tokenId Identifier number of a token.
    73
         * @param owner Address of the current owner of a token.
    74
         */
    75
        error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
    76
    
                                                    
                                                
    77
        /**
    78
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    79
         * @param sender Address whose tokens are being transferred.
    80
         */
    81
        error ERC721InvalidSender(address sender);
    82
    
                                                    
                                                
    83
        /**
    84
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    85
         * @param receiver Address to which tokens are being transferred.
    86
         */
    87
        error ERC721InvalidReceiver(address receiver);
    88
    
                                                    
                                                
    89
        /**
    90
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    91
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    92
         * @param tokenId Identifier number of a token.
    93
         */
    94
        error ERC721InsufficientApproval(address operator, uint256 tokenId);
    95
    
                                                    
                                                
    96
        /**
    97
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    98
         * @param approver Address initiating an approval operation.
    99
         */
    100
        error ERC721InvalidApprover(address approver);
    101
    
                                                    
                                                
    102
        /**
    103
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    104
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    105
         */
    106
        error ERC721InvalidOperator(address operator);
    107
    }
    108
    
                                                    
                                                
    109
    /**
    110
     * @dev Standard ERC-1155 Errors
    111
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
    112
     */
    113
    interface IERC1155Errors {
    114
        /**
    115
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    116
         * @param sender Address whose tokens are being transferred.
    117
         * @param balance Current balance for the interacting account.
    118
         * @param needed Minimum amount required to perform a transfer.
    119
         * @param tokenId Identifier number of a token.
    120
         */
    121
        error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
    122
    
                                                    
                                                
    123
        /**
    124
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    125
         * @param sender Address whose tokens are being transferred.
    126
         */
    127
        error ERC1155InvalidSender(address sender);
    128
    
                                                    
                                                
    129
        /**
    130
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    131
         * @param receiver Address to which tokens are being transferred.
    132
         */
    133
        error ERC1155InvalidReceiver(address receiver);
    134
    
                                                    
                                                
    135
        /**
    136
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    137
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    138
         * @param owner Address of the current owner of a token.
    139
         */
    140
        error ERC1155MissingApprovalForAll(address operator, address owner);
    141
    
                                                    
                                                
    142
        /**
    143
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    144
         * @param approver Address initiating an approval operation.
    145
         */
    146
        error ERC1155InvalidApprover(address approver);
    147
    
                                                    
                                                
    148
        /**
    149
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    150
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    151
         */
    152
        error ERC1155InvalidOperator(address operator);
    153
    
                                                    
                                                
    154
        /**
    155
         * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
    156
         * Used in batch transfers.
    157
         * @param idsLength Length of the array of token identifiers
    158
         * @param valuesLength Length of the array of token amounts
    159
         */
    160
        error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
    161
    }
    162
    
                                                    
                                                
    75.0% lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
    Lines covered: 42 / 56 (75.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/ERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {IERC20} from "./IERC20.sol";
    7
    import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
    8
    import {Context} from "../../utils/Context.sol";
    9
    import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
    10
    
                                                    
                                                
    11
    /**
    12
     * @dev Implementation of the {IERC20} interface.
    13
     *
    14
     * This implementation is agnostic to the way tokens are created. This means
    15
     * that a supply mechanism has to be added in a derived contract using {_mint}.
    16
     *
    17
     * TIP: For a detailed writeup see our guide
    18
     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
    19
     * to implement supply mechanisms].
    20
     *
    21
     * The default value of {decimals} is 18. To change this, you should override
    22
     * this function so it returns a different value.
    23
     *
    24
     * We have followed general OpenZeppelin Contracts guidelines: functions revert
    25
     * instead returning `false` on failure. This behavior is nonetheless
    26
     * conventional and does not conflict with the expectations of ERC-20
    27
     * applications.
    28
     */
    29
    abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    30
        mapping(address account => uint256) private _balances;
    31
    
                                                    
                                                
    32
        mapping(address account => mapping(address spender => uint256)) private _allowances;
    33
    
                                                    
                                                
    34
        uint256 private _totalSupply;
    35
    
                                                    
                                                
    36
        string private _name;
    37
        string private _symbol;
    38
    
                                                    
                                                
    39
        /**
    40
         * @dev Sets the values for {name} and {symbol}.
    41
         *
    42
         * Both values are immutable: they can only be set once during construction.
    43
         */
    44
        constructor(string memory name_, string memory symbol_) {
    45
    ✓ 1
            _name = name_;
    46
    ✓ 1
            _symbol = symbol_;
    47
        }
    48
    
                                                    
                                                
    49
        /**
    50
         * @dev Returns the name of the token.
    51
         */
    52
        function name() public view virtual returns (string memory) {
    53
            return _name;
    54
        }
    55
    
                                                    
                                                
    56
        /**
    57
         * @dev Returns the symbol of the token, usually a shorter version of the
    58
         * name.
    59
         */
    60
        function symbol() public view virtual returns (string memory) {
    61
            return _symbol;
    62
        }
    63
    
                                                    
                                                
    64
        /**
    65
         * @dev Returns the number of decimals used to get its user representation.
    66
         * For example, if `decimals` equals `2`, a balance of `505` tokens should
    67
         * be displayed to a user as `5.05` (`505 / 10 ** 2`).
    68
         *
    69
         * Tokens usually opt for a value of 18, imitating the relationship between
    70
         * Ether and Wei. This is the default value returned by this function, unless
    71
         * it's overridden.
    72
         *
    73
         * NOTE: This information is only used for _display_ purposes: it in
    74
         * no way affects any of the arithmetic of the contract, including
    75
         * {IERC20-balanceOf} and {IERC20-transfer}.
    76
         */
    77
        function decimals() public view virtual returns (uint8) {
    78
            return 18;
    79
        }
    80
    
                                                    
                                                
    81
        /// @inheritdoc IERC20
    82
        function totalSupply() public view virtual returns (uint256) {
    83
            return _totalSupply;
    84
        }
    85
    
                                                    
                                                
    86
        /// @inheritdoc IERC20
    87
    ✓ 300.0K
        function balanceOf(address account) public view virtual returns (uint256) {
    88
    ✓ 300.0K
            return _balances[account];
    89
        }
    90
    
                                                    
                                                
    91
        /**
    92
         * @dev See {IERC20-transfer}.
    93
         *
    94
         * Requirements:
    95
         *
    96
         * - `to` cannot be the zero address.
    97
         * - the caller must have a balance of at least `value`.
    98
         */
    99
    ✓ 50.0K
        function transfer(address to, uint256 value) public virtual returns (bool) {
    100
    ✓ 50.0K
            address owner = _msgSender();
    101
    ✓ 50.0K
            _transfer(owner, to, value);
    102
    ✓ 50.0K
            return true;
    103
        }
    104
    
                                                    
                                                
    105
        /// @inheritdoc IERC20
    106
    ✓ 100.0K
        function allowance(address owner, address spender) public view virtual returns (uint256) {
    107
    ✓ 100.0K
            return _allowances[owner][spender];
    108
        }
    109
    
                                                    
                                                
    110
        /**
    111
         * @dev See {IERC20-approve}.
    112
         *
    113
         * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
    114
         * `transferFrom`. This is semantically equivalent to an infinite approval.
    115
         *
    116
         * Requirements:
    117
         *
    118
         * - `spender` cannot be the zero address.
    119
         */
    120
    ✓ 1
        function approve(address spender, uint256 value) public virtual returns (bool) {
    121
    ✓ 1
            address owner = _msgSender();
    122
    ✓ 1
            _approve(owner, spender, value);
    123
    ✓ 1
            return true;
    124
        }
    125
    
                                                    
                                                
    126
        /**
    127
         * @dev See {IERC20-transferFrom}.
    128
         *
    129
         * Skips emitting an {Approval} event indicating an allowance update. This is not
    130
         * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
    131
         *
    132
         * NOTE: Does not update the allowance if the current allowance
    133
         * is the maximum `uint256`.
    134
         *
    135
         * Requirements:
    136
         *
    137
         * - `from` and `to` cannot be the zero address.
    138
         * - `from` must have a balance of at least `value`.
    139
         * - the caller must have allowance for ``from``'s tokens of at least
    140
         * `value`.
    141
         */
    142
    ✓ 100.0K
        function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
    143
    ✓ 100.0K
            address spender = _msgSender();
    144
    ✓ 100.0K
            _spendAllowance(from, spender, value);
    145
    ✓ 100.0K
            _transfer(from, to, value);
    146
    ✓ 100.0K
            return true;
    147
        }
    148
    
                                                    
                                                
    149
        /**
    150
         * @dev Moves a `value` amount of tokens from `from` to `to`.
    151
         *
    152
         * This internal function is equivalent to {transfer}, and can be used to
    153
         * e.g. implement automatic token fees, slashing mechanisms, etc.
    154
         *
    155
         * Emits a {Transfer} event.
    156
         *
    157
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    158
         */
    159
        function _transfer(address from, address to, uint256 value) internal {
    160
    ✓ 100.0K
            if (from == address(0)) {
    161
                revert ERC20InvalidSender(address(0));
    162
            }
    163
    ✓ 100.0K
            if (to == address(0)) {
    164
                revert ERC20InvalidReceiver(address(0));
    165
            }
    166
    ✓ 100.0K
            _update(from, to, value);
    167
        }
    168
    
                                                    
                                                
    169
        /**
    170
         * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
    171
         * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
    172
         * this function.
    173
         *
    174
         * Emits a {Transfer} event.
    175
         */
    176
        function _update(address from, address to, uint256 value) internal virtual {
    177
    ✓ 100.0K
            if (from == address(0)) {
    178
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
    179
    ✓ 1
                _totalSupply += value;
    180
            } else {
    181
    ✓ 100.0K
                uint256 fromBalance = _balances[from];
    182
    ✓ 100.0K
                if (fromBalance < value) {
    183
                    revert ERC20InsufficientBalance(from, fromBalance, value);
    184
                }
    185
                unchecked {
    186
                    // Overflow not possible: value <= fromBalance <= totalSupply.
    187
    ✓ 100.0K
                    _balances[from] = fromBalance - value;
    188
                }
    189
            }
    190
    
                                                    
                                                
    191
    ✓ 100.0K
            if (to == address(0)) {
    192
                unchecked {
    193
                    // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
    194
                    _totalSupply -= value;
    195
                }
    196
            } else {
    197
                unchecked {
    198
                    // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
    199
    ✓ 100.0K
                    _balances[to] += value;
    200
                }
    201
            }
    202
    
                                                    
                                                
    203
    ✓ 100.0K
            emit Transfer(from, to, value);
    204
        }
    205
    
                                                    
                                                
    206
        /**
    207
         * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
    208
         * Relies on the `_update` mechanism
    209
         *
    210
         * Emits a {Transfer} event with `from` set to the zero address.
    211
         *
    212
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    213
         */
    214
        function _mint(address account, uint256 value) internal {
    215
    ✓ 1
            if (account == address(0)) {
    216
                revert ERC20InvalidReceiver(address(0));
    217
            }
    218
    ✓ 1
            _update(address(0), account, value);
    219
        }
    220
    
                                                    
                                                
    221
        /**
    222
         * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
    223
         * Relies on the `_update` mechanism.
    224
         *
    225
         * Emits a {Transfer} event with `to` set to the zero address.
    226
         *
    227
         * NOTE: This function is not virtual, {_update} should be overridden instead
    228
         */
    229
        function _burn(address account, uint256 value) internal {
    230
            if (account == address(0)) {
    231
                revert ERC20InvalidSender(address(0));
    232
            }
    233
            _update(account, address(0), value);
    234
        }
    235
    
                                                    
                                                
    236
        /**
    237
         * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
    238
         *
    239
         * This internal function is equivalent to `approve`, and can be used to
    240
         * e.g. set automatic allowances for certain subsystems, etc.
    241
         *
    242
         * Emits an {Approval} event.
    243
         *
    244
         * Requirements:
    245
         *
    246
         * - `owner` cannot be the zero address.
    247
         * - `spender` cannot be the zero address.
    248
         *
    249
         * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
    250
         */
    251
        function _approve(address owner, address spender, uint256 value) internal {
    252
    ✓ 1
            _approve(owner, spender, value, true);
    253
        }
    254
    
                                                    
                                                
    255
        /**
    256
         * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
    257
         *
    258
         * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
    259
         * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
    260
         * `Approval` event during `transferFrom` operations.
    261
         *
    262
         * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
    263
         * true using the following override:
    264
         *
    265
         * ```solidity
    266
         * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
    267
         *     super._approve(owner, spender, value, true);
    268
         * }
    269
         * ```
    270
         *
    271
         * Requirements are the same as {_approve}.
    272
         */
    273
        function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
    274
    ✓ 100.0K
            if (owner == address(0)) {
    275
                revert ERC20InvalidApprover(address(0));
    276
            }
    277
    ✓ 100.0K
            if (spender == address(0)) {
    278
                revert ERC20InvalidSpender(address(0));
    279
            }
    280
    ✓ 100.0K
            _allowances[owner][spender] = value;
    281
    ✓ 100.0K
            if (emitEvent) {
    282
    ✓ 1
                emit Approval(owner, spender, value);
    283
            }
    284
        }
    285
    
                                                    
                                                
    286
        /**
    287
         * @dev Updates `owner`'s allowance for `spender` based on spent `value`.
    288
         *
    289
         * Does not update the allowance value in case of infinite allowance.
    290
         * Revert if not enough allowance is available.
    291
         *
    292
         * Does not emit an {Approval} event.
    293
         */
    294
        function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
    295
    ✓ 100.0K
            uint256 currentAllowance = allowance(owner, spender);
    296
    ✓ 100.0K
            if (currentAllowance < type(uint256).max) {
    297
    ✓ 100.0K
                if (currentAllowance < value) {
    298
                    revert ERC20InsufficientAllowance(spender, currentAllowance, value);
    299
                }
    300
                unchecked {
    301
    ✓ 100.0K
                    _approve(owner, spender, currentAllowance - value, false);
    302
                }
    303
            }
    304
        }
    305
    }
    306
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.4.16;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Interface of the ERC-20 standard as defined in the ERC.
    8
     */
    9
    interface IERC20 {
    10
        /**
    11
         * @dev Emitted when `value` tokens are moved from one account (`from`) to
    12
         * another (`to`).
    13
         *
    14
         * Note that `value` may be zero.
    15
         */
    16
        event Transfer(address indexed from, address indexed to, uint256 value);
    17
    
                                                    
                                                
    18
        /**
    19
         * @dev Emitted when the allowance of a `spender` for an `owner` is set by
    20
         * a call to {approve}. `value` is the new allowance.
    21
         */
    22
        event Approval(address indexed owner, address indexed spender, uint256 value);
    23
    
                                                    
                                                
    24
        /**
    25
         * @dev Returns the value of tokens in existence.
    26
         */
    27
        function totalSupply() external view returns (uint256);
    28
    
                                                    
                                                
    29
        /**
    30
         * @dev Returns the value of tokens owned by `account`.
    31
         */
    32
        function balanceOf(address account) external view returns (uint256);
    33
    
                                                    
                                                
    34
        /**
    35
         * @dev Moves a `value` amount of tokens from the caller's account to `to`.
    36
         *
    37
         * Returns a boolean value indicating whether the operation succeeded.
    38
         *
    39
         * Emits a {Transfer} event.
    40
         */
    41
        function transfer(address to, uint256 value) external returns (bool);
    42
    
                                                    
                                                
    43
        /**
    44
         * @dev Returns the remaining number of tokens that `spender` will be
    45
         * allowed to spend on behalf of `owner` through {transferFrom}. This is
    46
         * zero by default.
    47
         *
    48
         * This value changes when {approve} or {transferFrom} are called.
    49
         */
    50
        function allowance(address owner, address spender) external view returns (uint256);
    51
    
                                                    
                                                
    52
        /**
    53
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    54
         * caller's tokens.
    55
         *
    56
         * Returns a boolean value indicating whether the operation succeeded.
    57
         *
    58
         * IMPORTANT: Beware that changing an allowance with this method brings the risk
    59
         * that someone may use both the old and the new allowance by unfortunate
    60
         * transaction ordering. One possible solution to mitigate this race
    61
         * condition is to first reduce the spender's allowance to 0 and set the
    62
         * desired value afterwards:
    63
         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    64
         *
    65
         * Emits an {Approval} event.
    66
         */
    67
        function approve(address spender, uint256 value) external returns (bool);
    68
    
                                                    
                                                
    69
        /**
    70
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
    71
         * allowance mechanism. `value` is then deducted from the caller's
    72
         * allowance.
    73
         *
    74
         * Returns a boolean value indicating whether the operation succeeded.
    75
         *
    76
         * Emits a {Transfer} event.
    77
         */
    78
        function transferFrom(address from, address to, uint256 value) external returns (bool);
    79
    }
    80
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.6.2;
    5
    
                                                    
                                                
    6
    import {IERC20} from "../IERC20.sol";
    7
    
                                                    
                                                
    8
    /**
    9
     * @dev Interface for the optional metadata functions from the ERC-20 standard.
    10
     */
    11
    interface IERC20Metadata is IERC20 {
    12
        /**
    13
         * @dev Returns the name of the token.
    14
         */
    15
        function name() external view returns (string memory);
    16
    
                                                    
                                                
    17
        /**
    18
         * @dev Returns the symbol of the token.
    19
         */
    20
        function symbol() external view returns (string memory);
    21
    
                                                    
                                                
    22
        /**
    23
         * @dev Returns the decimals places of the token.
    24
         */
    25
        function decimals() external view returns (uint8);
    26
    }
    27
    
                                                    
                                                
    71.4% lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol
    Lines covered: 10 / 14 (71.4%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {IERC20} from "../IERC20.sol";
    7
    import {IERC1363} from "../../../interfaces/IERC1363.sol";
    8
    
                                                    
                                                
    9
    /**
    10
     * @title SafeERC20
    11
     * @dev Wrappers around ERC-20 operations that throw on failure (when the token
    12
     * contract returns false). Tokens that return no value (and instead revert or
    13
     * throw on failure) are also supported, non-reverting calls are assumed to be
    14
     * successful.
    15
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
    16
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    17
     */
    18
    ✓ 15
    library SafeERC20 {
    19
        /**
    20
         * @dev An operation with an ERC-20 token failed.
    21
         */
    22
        error SafeERC20FailedOperation(address token);
    23
    
                                                    
                                                
    24
        /**
    25
         * @dev Indicates a failed `decreaseAllowance` request.
    26
         */
    27
        error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
    28
    
                                                    
                                                
    29
        /**
    30
         * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
    31
         * non-reverting calls are assumed to be successful.
    32
         */
    33
        function safeTransfer(IERC20 token, address to, uint256 value) internal {
    34
    ✓ 50.0K
            _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    35
        }
    36
    
                                                    
                                                
    37
        /**
    38
         * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
    39
         * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
    40
         */
    41
        function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    42
    ✓ 150.0K
            _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    43
        }
    44
    
                                                    
                                                
    45
        /**
    46
         * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
    47
         */
    48
        function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
    49
            return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    50
        }
    51
    
                                                    
                                                
    52
        /**
    53
         * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
    54
         */
    55
        function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
    56
            return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    57
        }
    58
    
                                                    
                                                
    59
        /**
    60
         * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
    61
         * non-reverting calls are assumed to be successful.
    62
         *
    63
         * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
    64
         * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
    65
         * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
    66
         * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
    67
         */
    68
        function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    69
            uint256 oldAllowance = token.allowance(address(this), spender);
    70
            forceApprove(token, spender, oldAllowance + value);
    71
        }
    72
    
                                                    
                                                
    73
        /**
    74
         * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
    75
         * value, non-reverting calls are assumed to be successful.
    76
         *
    77
         * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
    78
         * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
    79
         * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
    80
         * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
    81
         */
    82
        function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
    83
            unchecked {
    84
                uint256 currentAllowance = token.allowance(address(this), spender);
    85
                if (currentAllowance < requestedDecrease) {
    86
                    revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
    87
                }
    88
                forceApprove(token, spender, currentAllowance - requestedDecrease);
    89
            }
    90
        }
    91
    
                                                    
                                                
    92
        /**
    93
         * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
    94
         * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
    95
         * to be set to zero before setting it to a non-zero value, such as USDT.
    96
         *
    97
         * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
    98
         * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
    99
         * set here.
    100
         */
    101
        function forceApprove(IERC20 token, address spender, uint256 value) internal {
    102
            bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
    103
    
                                                    
                                                
    104
            if (!_callOptionalReturnBool(token, approvalCall)) {
    105
                _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
    106
                _callOptionalReturn(token, approvalCall);
    107
            }
    108
        }
    109
    
                                                    
                                                
    110
        /**
    111
         * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
    112
         * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
    113
         * targeting contracts.
    114
         *
    115
         * Reverts if the returned value is other than `true`.
    116
         */
    117
        function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
    118
            if (to.code.length == 0) {
    119
                safeTransfer(token, to, value);
    120
            } else if (!token.transferAndCall(to, value, data)) {
    121
                revert SafeERC20FailedOperation(address(token));
    122
            }
    123
        }
    124
    
                                                    
                                                
    125
        /**
    126
         * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
    127
         * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
    128
         * targeting contracts.
    129
         *
    130
         * Reverts if the returned value is other than `true`.
    131
         */
    132
        function transferFromAndCallRelaxed(
    133
            IERC1363 token,
    134
            address from,
    135
            address to,
    136
            uint256 value,
    137
            bytes memory data
    138
        ) internal {
    139
            if (to.code.length == 0) {
    140
                safeTransferFrom(token, from, to, value);
    141
            } else if (!token.transferFromAndCall(from, to, value, data)) {
    142
                revert SafeERC20FailedOperation(address(token));
    143
            }
    144
        }
    145
    
                                                    
                                                
    146
        /**
    147
         * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
    148
         * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
    149
         * targeting contracts.
    150
         *
    151
         * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
    152
         * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
    153
         * once without retrying, and relies on the returned value to be true.
    154
         *
    155
         * Reverts if the returned value is other than `true`.
    156
         */
    157
        function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
    158
            if (to.code.length == 0) {
    159
                forceApprove(token, to, value);
    160
            } else if (!token.approveAndCall(to, value, data)) {
    161
                revert SafeERC20FailedOperation(address(token));
    162
            }
    163
        }
    164
    
                                                    
                                                
    165
        /**
    166
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
    167
         * on the return value: the return value is optional (but if data is returned, it must not be false).
    168
         * @param token The token targeted by the call.
    169
         * @param data The call data (encoded using abi.encode or one of its variants).
    170
         *
    171
         * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
    172
         */
    173
        function _callOptionalReturn(IERC20 token, bytes memory data) private {
    174
    ✓ 200.0K
            uint256 returnSize;
    175
    ✓ 200.0K
            uint256 returnValue;
    176
            assembly ("memory-safe") {
    177
    ✓ 200.0K
                let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
    178
                // bubble errors
    179
    ✓ 200.0K
                if iszero(success) {
    180
                    let ptr := mload(0x40)
    181
                    returndatacopy(ptr, 0, returndatasize())
    182
                    revert(ptr, returndatasize())
    183
                }
    184
    ✓ 200.0K
                returnSize := returndatasize()
    185
    ✓ 200.0K
                returnValue := mload(0)
    186
            }
    187
    
                                                    
                                                
    188
    ✓ 200.0K
            if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
    189
                revert SafeERC20FailedOperation(address(token));
    190
            }
    191
        }
    192
    
                                                    
                                                
    193
        /**
    194
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
    195
         * on the return value: the return value is optional (but if data is returned, it must not be false).
    196
         * @param token The token targeted by the call.
    197
         * @param data The call data (encoded using abi.encode or one of its variants).
    198
         *
    199
         * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
    200
         */
    201
        function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
    202
            bool success;
    203
            uint256 returnSize;
    204
            uint256 returnValue;
    205
            assembly ("memory-safe") {
    206
                success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
    207
                returnSize := returndatasize()
    208
                returnValue := mload(0)
    209
            }
    210
            return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    211
        }
    212
    }
    213
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/contracts/utils/Context.sol
    Lines covered: 2 / 2 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Provides information about the current execution context, including the
    8
     * sender of the transaction and its data. While these are generally available
    9
     * via msg.sender and msg.data, they should not be accessed in such a direct
    10
     * manner, since when dealing with meta-transactions the account sending and
    11
     * paying for execution may not be the actual sender (as far as an application
    12
     * is concerned).
    13
     *
    14
     * This contract is only required for intermediate, library-like contracts.
    15
     */
    16
    abstract contract Context {
    17
    ✓ 100.0K
        function _msgSender() internal view virtual returns (address) {
    18
    ✓ 100.0K
            return msg.sender;
    19
        }
    20
    
                                                    
                                                
    21
        function _msgData() internal view virtual returns (bytes calldata) {
    22
            return msg.data;
    23
        }
    24
    
                                                    
                                                
    25
        function _contextSuffixLength() internal view virtual returns (uint256) {
    26
            return 0;
    27
        }
    28
    }
    29
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/contracts/utils/Panic.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Helper library for emitting standardized panic codes.
    8
     *
    9
     * ```solidity
    10
     * contract Example {
    11
     *      using Panic for uint256;
    12
     *
    13
     *      // Use any of the declared internal constants
    14
     *      function foo() { Panic.GENERIC.panic(); }
    15
     *
    16
     *      // Alternatively
    17
     *      function foo() { Panic.panic(Panic.GENERIC); }
    18
     * }
    19
     * ```
    20
     *
    21
     * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
    22
     *
    23
     * _Available since v5.1._
    24
     */
    25
    // slither-disable-next-line unused-state
    26
    ✓ 15
    library Panic {
    27
        /// @dev generic / unspecified error
    28
        uint256 internal constant GENERIC = 0x00;
    29
        /// @dev used by the assert() builtin
    30
        uint256 internal constant ASSERT = 0x01;
    31
        /// @dev arithmetic underflow or overflow
    32
        uint256 internal constant UNDER_OVERFLOW = 0x11;
    33
        /// @dev division or modulo by zero
    34
        uint256 internal constant DIVISION_BY_ZERO = 0x12;
    35
        /// @dev enum conversion error
    36
        uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    37
        /// @dev invalid encoding in storage
    38
        uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    39
        /// @dev empty array pop
    40
        uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    41
        /// @dev array out of bounds access
    42
        uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    43
        /// @dev resource error (too large allocation or too large array)
    44
        uint256 internal constant RESOURCE_ERROR = 0x41;
    45
        /// @dev calling invalid internal function
    46
        uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
    47
    
                                                    
                                                
    48
        /// @dev Reverts with a panic code. Recommended to use with
    49
        /// the internal constants with predefined codes.
    50
        function panic(uint256 code) internal pure {
    51
            assembly ("memory-safe") {
    52
                mstore(0x00, 0x4e487b71)
    53
                mstore(0x20, code)
    54
                revert(0x1c, 0x24)
    55
            }
    56
        }
    57
    }
    58
    
                                                    
                                                
    4.3% lib/openzeppelin-contracts/contracts/utils/Strings.sol
    Lines covered: 1 / 23 (4.3%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (utils/Strings.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {Math} from "./math/Math.sol";
    7
    import {SafeCast} from "./math/SafeCast.sol";
    8
    import {SignedMath} from "./math/SignedMath.sol";
    9
    
                                                    
                                                
    10
    /**
    11
     * @dev String operations.
    12
     */
    13
    ✓ 15
    library Strings {
    14
        using SafeCast for *;
    15
    
                                                    
                                                
    16
        bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    17
        uint8 private constant ADDRESS_LENGTH = 20;
    18
        uint256 private constant SPECIAL_CHARS_LOOKUP =
    19
            (1 << 0x08) | // backspace
    20
                (1 << 0x09) | // tab
    21
                (1 << 0x0a) | // newline
    22
                (1 << 0x0c) | // form feed
    23
                (1 << 0x0d) | // carriage return
    24
                (1 << 0x22) | // double quote
    25
                (1 << 0x5c); // backslash
    26
    
                                                    
                                                
    27
        /**
    28
         * @dev The `value` string doesn't fit in the specified `length`.
    29
         */
    30
        error StringsInsufficientHexLength(uint256 value, uint256 length);
    31
    
                                                    
                                                
    32
        /**
    33
         * @dev The string being parsed contains characters that are not in scope of the given base.
    34
         */
    35
        error StringsInvalidChar();
    36
    
                                                    
                                                
    37
        /**
    38
         * @dev The string being parsed is not a properly formatted address.
    39
         */
    40
        error StringsInvalidAddressFormat();
    41
    
                                                    
                                                
    42
        /**
    43
         * @dev Converts a `uint256` to its ASCII `string` decimal representation.
    44
         */
    45
        function toString(uint256 value) internal pure returns (string memory) {
    46
            unchecked {
    47
                uint256 length = Math.log10(value) + 1;
    48
                string memory buffer = new string(length);
    49
                uint256 ptr;
    50
                assembly ("memory-safe") {
    51
                    ptr := add(add(buffer, 0x20), length)
    52
                }
    53
                while (true) {
    54
                    ptr--;
    55
                    assembly ("memory-safe") {
    56
                        mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
    57
                    }
    58
                    value /= 10;
    59
                    if (value == 0) break;
    60
                }
    61
                return buffer;
    62
            }
    63
        }
    64
    
                                                    
                                                
    65
        /**
    66
         * @dev Converts a `int256` to its ASCII `string` decimal representation.
    67
         */
    68
        function toStringSigned(int256 value) internal pure returns (string memory) {
    69
            return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    70
        }
    71
    
                                                    
                                                
    72
        /**
    73
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
    74
         */
    75
        function toHexString(uint256 value) internal pure returns (string memory) {
    76
            unchecked {
    77
                return toHexString(value, Math.log256(value) + 1);
    78
            }
    79
        }
    80
    
                                                    
                                                
    81
        /**
    82
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
    83
         */
    84
        function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
    85
            uint256 localValue = value;
    86
            bytes memory buffer = new bytes(2 * length + 2);
    87
            buffer[0] = "0";
    88
            buffer[1] = "x";
    89
            for (uint256 i = 2 * length + 1; i > 1; --i) {
    90
                buffer[i] = HEX_DIGITS[localValue & 0xf];
    91
                localValue >>= 4;
    92
            }
    93
            if (localValue != 0) {
    94
                revert StringsInsufficientHexLength(value, length);
    95
            }
    96
            return string(buffer);
    97
        }
    98
    
                                                    
                                                
    99
        /**
    100
         * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
    101
         * representation.
    102
         */
    103
        function toHexString(address addr) internal pure returns (string memory) {
    104
            return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    105
        }
    106
    
                                                    
                                                
    107
        /**
    108
         * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
    109
         * representation, according to EIP-55.
    110
         */
    111
        function toChecksumHexString(address addr) internal pure returns (string memory) {
    112
            bytes memory buffer = bytes(toHexString(addr));
    113
    
                                                    
                                                
    114
            // hash the hex part of buffer (skip length + 2 bytes, length 40)
    115
            uint256 hashValue;
    116
            assembly ("memory-safe") {
    117
                hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
    118
            }
    119
    
                                                    
                                                
    120
            for (uint256 i = 41; i > 1; --i) {
    121
                // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
    122
                if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
    123
                    // case shift by xoring with 0x20
    124
                    buffer[i] ^= 0x20;
    125
                }
    126
                hashValue >>= 4;
    127
            }
    128
            return string(buffer);
    129
        }
    130
    
                                                    
                                                
    131
        /**
    132
         * @dev Returns true if the two strings are equal.
    133
         */
    134
        function equal(string memory a, string memory b) internal pure returns (bool) {
    135
            return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    136
        }
    137
    
                                                    
                                                
    138
        /**
    139
         * @dev Parse a decimal string and returns the value as a `uint256`.
    140
         *
    141
         * Requirements:
    142
         * - The string must be formatted as `[0-9]*`
    143
         * - The result must fit into an `uint256` type
    144
         */
    145
        function parseUint(string memory input) internal pure returns (uint256) {
    146
            return parseUint(input, 0, bytes(input).length);
    147
        }
    148
    
                                                    
                                                
    149
        /**
    150
         * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and
    151
         * `end` (excluded).
    152
         *
    153
         * Requirements:
    154
         * - The substring must be formatted as `[0-9]*`
    155
         * - The result must fit into an `uint256` type
    156
         */
    157
        function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
    158
            (bool success, uint256 value) = tryParseUint(input, begin, end);
    159
            if (!success) revert StringsInvalidChar();
    160
            return value;
    161
        }
    162
    
                                                    
                                                
    163
        /**
    164
         * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.
    165
         *
    166
         * NOTE: This function will revert if the result does not fit in a `uint256`.
    167
         */
    168
        function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {
    169
            return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);
    170
        }
    171
    
                                                    
                                                
    172
        /**
    173
         * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid
    174
         * character.
    175
         *
    176
         * NOTE: This function will revert if the result does not fit in a `uint256`.
    177
         */
    178
        function tryParseUint(
    179
            string memory input,
    180
            uint256 begin,
    181
            uint256 end
    182
        ) internal pure returns (bool success, uint256 value) {
    183
            if (end > bytes(input).length || begin > end) return (false, 0);
    184
            return _tryParseUintUncheckedBounds(input, begin, end);
    185
        }
    186
    
                                                    
                                                
    187
        /**
    188
         * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
    189
         * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
    190
         */
    191
        function _tryParseUintUncheckedBounds(
    192
            string memory input,
    193
            uint256 begin,
    194
            uint256 end
    195
        ) private pure returns (bool success, uint256 value) {
    196
            bytes memory buffer = bytes(input);
    197
    
                                                    
                                                
    198
            uint256 result = 0;
    199
            for (uint256 i = begin; i < end; ++i) {
    200
                uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
    201
                if (chr > 9) return (false, 0);
    202
                result *= 10;
    203
                result += chr;
    204
            }
    205
            return (true, result);
    206
        }
    207
    
                                                    
                                                
    208
        /**
    209
         * @dev Parse a decimal string and returns the value as a `int256`.
    210
         *
    211
         * Requirements:
    212
         * - The string must be formatted as `[-+]?[0-9]*`
    213
         * - The result must fit in an `int256` type.
    214
         */
    215
        function parseInt(string memory input) internal pure returns (int256) {
    216
            return parseInt(input, 0, bytes(input).length);
    217
        }
    218
    
                                                    
                                                
    219
        /**
    220
         * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and
    221
         * `end` (excluded).
    222
         *
    223
         * Requirements:
    224
         * - The substring must be formatted as `[-+]?[0-9]*`
    225
         * - The result must fit in an `int256` type.
    226
         */
    227
        function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {
    228
            (bool success, int256 value) = tryParseInt(input, begin, end);
    229
            if (!success) revert StringsInvalidChar();
    230
            return value;
    231
        }
    232
    
                                                    
                                                
    233
        /**
    234
         * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if
    235
         * the result does not fit in a `int256`.
    236
         *
    237
         * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
    238
         */
    239
        function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {
    240
            return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);
    241
        }
    242
    
                                                    
                                                
    243
        uint256 private constant ABS_MIN_INT256 = 2 ** 255;
    244
    
                                                    
                                                
    245
        /**
    246
         * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid
    247
         * character or if the result does not fit in a `int256`.
    248
         *
    249
         * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
    250
         */
    251
        function tryParseInt(
    252
            string memory input,
    253
            uint256 begin,
    254
            uint256 end
    255
        ) internal pure returns (bool success, int256 value) {
    256
            if (end > bytes(input).length || begin > end) return (false, 0);
    257
            return _tryParseIntUncheckedBounds(input, begin, end);
    258
        }
    259
    
                                                    
                                                
    260
        /**
    261
         * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that
    262
         * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
    263
         */
    264
        function _tryParseIntUncheckedBounds(
    265
            string memory input,
    266
            uint256 begin,
    267
            uint256 end
    268
        ) private pure returns (bool success, int256 value) {
    269
            bytes memory buffer = bytes(input);
    270
    
                                                    
                                                
    271
            // Check presence of a negative sign.
    272
            bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
    273
            bool positiveSign = sign == bytes1("+");
    274
            bool negativeSign = sign == bytes1("-");
    275
            uint256 offset = (positiveSign || negativeSign).toUint();
    276
    
                                                    
                                                
    277
            (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);
    278
    
                                                    
                                                
    279
            if (absSuccess && absValue < ABS_MIN_INT256) {
    280
                return (true, negativeSign ? -int256(absValue) : int256(absValue));
    281
            } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {
    282
                return (true, type(int256).min);
    283
            } else return (false, 0);
    284
        }
    285
    
                                                    
                                                
    286
        /**
    287
         * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a `uint256`.
    288
         *
    289
         * Requirements:
    290
         * - The string must be formatted as `(0x)?[0-9a-fA-F]*`
    291
         * - The result must fit in an `uint256` type.
    292
         */
    293
        function parseHexUint(string memory input) internal pure returns (uint256) {
    294
            return parseHexUint(input, 0, bytes(input).length);
    295
        }
    296
    
                                                    
                                                
    297
        /**
    298
         * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and
    299
         * `end` (excluded).
    300
         *
    301
         * Requirements:
    302
         * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`
    303
         * - The result must fit in an `uint256` type.
    304
         */
    305
        function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
    306
            (bool success, uint256 value) = tryParseHexUint(input, begin, end);
    307
            if (!success) revert StringsInvalidChar();
    308
            return value;
    309
        }
    310
    
                                                    
                                                
    311
        /**
    312
         * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.
    313
         *
    314
         * NOTE: This function will revert if the result does not fit in a `uint256`.
    315
         */
    316
        function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {
    317
            return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);
    318
        }
    319
    
                                                    
                                                
    320
        /**
    321
         * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an
    322
         * invalid character.
    323
         *
    324
         * NOTE: This function will revert if the result does not fit in a `uint256`.
    325
         */
    326
        function tryParseHexUint(
    327
            string memory input,
    328
            uint256 begin,
    329
            uint256 end
    330
        ) internal pure returns (bool success, uint256 value) {
    331
            if (end > bytes(input).length || begin > end) return (false, 0);
    332
            return _tryParseHexUintUncheckedBounds(input, begin, end);
    333
        }
    334
    
                                                    
                                                
    335
        /**
    336
         * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
    337
         * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
    338
         */
    339
        function _tryParseHexUintUncheckedBounds(
    340
            string memory input,
    341
            uint256 begin,
    342
            uint256 end
    343
        ) private pure returns (bool success, uint256 value) {
    344
            bytes memory buffer = bytes(input);
    345
    
                                                    
                                                
    346
            // skip 0x prefix if present
    347
            bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
    348
            uint256 offset = hasPrefix.toUint() * 2;
    349
    
                                                    
                                                
    350
            uint256 result = 0;
    351
            for (uint256 i = begin + offset; i < end; ++i) {
    352
                uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
    353
                if (chr > 15) return (false, 0);
    354
                result *= 16;
    355
                unchecked {
    356
                    // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).
    357
                    // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.
    358
                    result += chr;
    359
                }
    360
            }
    361
            return (true, result);
    362
        }
    363
    
                                                    
                                                
    364
        /**
    365
         * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an `address`.
    366
         *
    367
         * Requirements:
    368
         * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`
    369
         */
    370
        function parseAddress(string memory input) internal pure returns (address) {
    371
            return parseAddress(input, 0, bytes(input).length);
    372
        }
    373
    
                                                    
                                                
    374
        /**
    375
         * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and
    376
         * `end` (excluded).
    377
         *
    378
         * Requirements:
    379
         * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`
    380
         */
    381
        function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {
    382
            (bool success, address value) = tryParseAddress(input, begin, end);
    383
            if (!success) revert StringsInvalidAddressFormat();
    384
            return value;
    385
        }
    386
    
                                                    
                                                
    387
        /**
    388
         * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly
    389
         * formatted address. See {parseAddress-string} requirements.
    390
         */
    391
        function tryParseAddress(string memory input) internal pure returns (bool success, address value) {
    392
            return tryParseAddress(input, 0, bytes(input).length);
    393
        }
    394
    
                                                    
                                                
    395
        /**
    396
         * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly
    397
         * formatted address. See {parseAddress-string-uint256-uint256} requirements.
    398
         */
    399
        function tryParseAddress(
    400
            string memory input,
    401
            uint256 begin,
    402
            uint256 end
    403
        ) internal pure returns (bool success, address value) {
    404
            if (end > bytes(input).length || begin > end) return (false, address(0));
    405
    
                                                    
                                                
    406
            bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
    407
            uint256 expectedLength = 40 + hasPrefix.toUint() * 2;
    408
    
                                                    
                                                
    409
            // check that input is the correct length
    410
            if (end - begin == expectedLength) {
    411
                // length guarantees that this does not overflow, and value is at most type(uint160).max
    412
                (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);
    413
                return (s, address(uint160(v)));
    414
            } else {
    415
                return (false, address(0));
    416
            }
    417
        }
    418
    
                                                    
                                                
    419
        function _tryParseChr(bytes1 chr) private pure returns (uint8) {
    420
            uint8 value = uint8(chr);
    421
    
                                                    
                                                
    422
            // Try to parse `chr`:
    423
            // - Case 1: [0-9]
    424
            // - Case 2: [a-f]
    425
            // - Case 3: [A-F]
    426
            // - otherwise not supported
    427
            unchecked {
    428
                if (value > 47 && value < 58) value -= 48;
    429
                else if (value > 96 && value < 103) value -= 87;
    430
                else if (value > 64 && value < 71) value -= 55;
    431
                else return type(uint8).max;
    432
            }
    433
    
                                                    
                                                
    434
            return value;
    435
        }
    436
    
                                                    
                                                
    437
        /**
    438
         * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.
    439
         *
    440
         * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.
    441
         *
    442
         * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of
    443
         * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode
    444
         * characters that are not in this range, but other tooling may provide different results.
    445
         */
    446
        function escapeJSON(string memory input) internal pure returns (string memory) {
    447
            bytes memory buffer = bytes(input);
    448
            bytes memory output = new bytes(2 * buffer.length); // worst case scenario
    449
            uint256 outputLength = 0;
    450
    
                                                    
                                                
    451
            for (uint256 i; i < buffer.length; ++i) {
    452
                bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i));
    453
                if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) {
    454
                    output[outputLength++] = "\\";
    455
                    if (char == 0x08) output[outputLength++] = "b";
    456
                    else if (char == 0x09) output[outputLength++] = "t";
    457
                    else if (char == 0x0a) output[outputLength++] = "n";
    458
                    else if (char == 0x0c) output[outputLength++] = "f";
    459
                    else if (char == 0x0d) output[outputLength++] = "r";
    460
                    else if (char == 0x5c) output[outputLength++] = "\\";
    461
                    else if (char == 0x22) {
    462
                        // solhint-disable-next-line quotes
    463
                        output[outputLength++] = '"';
    464
                    }
    465
                } else {
    466
                    output[outputLength++] = char;
    467
                }
    468
            }
    469
            // write the actual length and deallocate unused memory
    470
            assembly ("memory-safe") {
    471
                mstore(output, outputLength)
    472
                mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63)))))
    473
            }
    474
    
                                                    
                                                
    475
            return string(output);
    476
        }
    477
    
                                                    
                                                
    478
        /**
    479
         * @dev Reads a bytes32 from a bytes array without bounds checking.
    480
         *
    481
         * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the
    482
         * assembly block as such would prevent some optimizations.
    483
         */
    484
        function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {
    485
            // This is not memory safe in the general case, but all calls to this private function are within bounds.
    486
            assembly ("memory-safe") {
    487
                value := mload(add(add(buffer, 0x20), offset))
    488
            }
    489
        }
    490
    }
    491
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)
    3
    
                                                    
                                                
    4
    pragma solidity >=0.4.16;
    5
    
                                                    
                                                
    6
    /**
    7
     * @dev Interface of the ERC-165 standard, as defined in the
    8
     * https://eips.ethereum.org/EIPS/eip-165[ERC].
    9
     *
    10
     * Implementers can declare support of contract interfaces, which can then be
    11
     * queried by others ({ERC165Checker}).
    12
     *
    13
     * For an implementation, see {ERC165}.
    14
     */
    15
    interface IERC165 {
    16
        /**
    17
         * @dev Returns true if this contract implements the interface defined by
    18
         * `interfaceId`. See the corresponding
    19
         * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
    20
         * to learn more about how these ids are created.
    21
         *
    22
         * This function call must use less than 30 000 gas.
    23
         */
    24
        function supportsInterface(bytes4 interfaceId) external view returns (bool);
    25
    }
    26
    
                                                    
                                                
    4.2% lib/openzeppelin-contracts/contracts/utils/math/Math.sol
    Lines covered: 1 / 24 (4.2%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {Panic} from "../Panic.sol";
    7
    import {SafeCast} from "./SafeCast.sol";
    8
    
                                                    
                                                
    9
    /**
    10
     * @dev Standard math utilities missing in the Solidity language.
    11
     */
    12
    ✓ 15
    library Math {
    13
        enum Rounding {
    14
            Floor, // Toward negative infinity
    15
            Ceil, // Toward positive infinity
    16
            Trunc, // Toward zero
    17
            Expand // Away from zero
    18
        }
    19
    
                                                    
                                                
    20
        /**
    21
         * @dev Return the 512-bit addition of two uint256.
    22
         *
    23
         * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.
    24
         */
    25
        function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
    26
            assembly ("memory-safe") {
    27
                low := add(a, b)
    28
                high := lt(low, a)
    29
            }
    30
        }
    31
    
                                                    
                                                
    32
        /**
    33
         * @dev Return the 512-bit multiplication of two uint256.
    34
         *
    35
         * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.
    36
         */
    37
        function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
    38
            // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
    39
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
    40
            // variables such that product = high * 2²⁵⁶ + low.
    41
            assembly ("memory-safe") {
    42
                let mm := mulmod(a, b, not(0))
    43
                low := mul(a, b)
    44
                high := sub(sub(mm, low), lt(mm, low))
    45
            }
    46
        }
    47
    
                                                    
                                                
    48
        /**
    49
         * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).
    50
         */
    51
        function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    52
            unchecked {
    53
                uint256 c = a + b;
    54
                success = c >= a;
    55
                result = c * SafeCast.toUint(success);
    56
            }
    57
        }
    58
    
                                                    
                                                
    59
        /**
    60
         * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).
    61
         */
    62
        function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    63
            unchecked {
    64
                uint256 c = a - b;
    65
                success = c <= a;
    66
                result = c * SafeCast.toUint(success);
    67
            }
    68
        }
    69
    
                                                    
                                                
    70
        /**
    71
         * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).
    72
         */
    73
        function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    74
            unchecked {
    75
                uint256 c = a * b;
    76
                assembly ("memory-safe") {
    77
                    // Only true when the multiplication doesn't overflow
    78
                    // (c / a == b) || (a == 0)
    79
                    success := or(eq(div(c, a), b), iszero(a))
    80
                }
    81
                // equivalent to: success ? c : 0
    82
                result = c * SafeCast.toUint(success);
    83
            }
    84
        }
    85
    
                                                    
                                                
    86
        /**
    87
         * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
    88
         */
    89
        function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    90
            unchecked {
    91
                success = b > 0;
    92
                assembly ("memory-safe") {
    93
                    // The `DIV` opcode returns zero when the denominator is 0.
    94
                    result := div(a, b)
    95
                }
    96
            }
    97
        }
    98
    
                                                    
                                                
    99
        /**
    100
         * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
    101
         */
    102
        function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    103
            unchecked {
    104
                success = b > 0;
    105
                assembly ("memory-safe") {
    106
                    // The `MOD` opcode returns zero when the denominator is 0.
    107
                    result := mod(a, b)
    108
                }
    109
            }
    110
        }
    111
    
                                                    
                                                
    112
        /**
    113
         * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.
    114
         */
    115
        function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {
    116
            (bool success, uint256 result) = tryAdd(a, b);
    117
            return ternary(success, result, type(uint256).max);
    118
        }
    119
    
                                                    
                                                
    120
        /**
    121
         * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.
    122
         */
    123
        function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {
    124
            (, uint256 result) = trySub(a, b);
    125
            return result;
    126
        }
    127
    
                                                    
                                                
    128
        /**
    129
         * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.
    130
         */
    131
        function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {
    132
            (bool success, uint256 result) = tryMul(a, b);
    133
            return ternary(success, result, type(uint256).max);
    134
        }
    135
    
                                                    
                                                
    136
        /**
    137
         * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
    138
         *
    139
         * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
    140
         * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
    141
         * one branch when needed, making this function more expensive.
    142
         */
    143
        function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
    144
            unchecked {
    145
                // branchless ternary works because:
    146
                // b ^ (a ^ b) == a
    147
                // b ^ 0 == b
    148
                return b ^ ((a ^ b) * SafeCast.toUint(condition));
    149
            }
    150
        }
    151
    
                                                    
                                                
    152
        /**
    153
         * @dev Returns the largest of two numbers.
    154
         */
    155
        function max(uint256 a, uint256 b) internal pure returns (uint256) {
    156
            return ternary(a > b, a, b);
    157
        }
    158
    
                                                    
                                                
    159
        /**
    160
         * @dev Returns the smallest of two numbers.
    161
         */
    162
        function min(uint256 a, uint256 b) internal pure returns (uint256) {
    163
            return ternary(a < b, a, b);
    164
        }
    165
    
                                                    
                                                
    166
        /**
    167
         * @dev Returns the average of two numbers. The result is rounded towards
    168
         * zero.
    169
         */
    170
        function average(uint256 a, uint256 b) internal pure returns (uint256) {
    171
            // (a + b) / 2 can overflow.
    172
            return (a & b) + (a ^ b) / 2;
    173
        }
    174
    
                                                    
                                                
    175
        /**
    176
         * @dev Returns the ceiling of the division of two numbers.
    177
         *
    178
         * This differs from standard division with `/` in that it rounds towards infinity instead
    179
         * of rounding towards zero.
    180
         */
    181
        function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
    182
            if (b == 0) {
    183
                // Guarantee the same behavior as in a regular Solidity division.
    184
                Panic.panic(Panic.DIVISION_BY_ZERO);
    185
            }
    186
    
                                                    
                                                
    187
            // The following calculation ensures accurate ceiling division without overflow.
    188
            // Since a is non-zero, (a - 1) / b will not overflow.
    189
            // The largest possible result occurs when (a - 1) / b is type(uint256).max,
    190
            // but the largest value we can obtain is type(uint256).max - 1, which happens
    191
            // when a = type(uint256).max and b = 1.
    192
            unchecked {
    193
                return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
    194
            }
    195
        }
    196
    
                                                    
                                                
    197
        /**
    198
         * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
    199
         * denominator == 0.
    200
         *
    201
         * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
    202
         * Uniswap Labs also under MIT license.
    203
         */
    204
        function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
    205
            unchecked {
    206
                (uint256 high, uint256 low) = mul512(x, y);
    207
    
                                                    
                                                
    208
                // Handle non-overflow cases, 256 by 256 division.
    209
                if (high == 0) {
    210
                    // Solidity will revert if denominator == 0, unlike the div opcode on its own.
    211
                    // The surrounding unchecked block does not change this fact.
    212
                    // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
    213
                    return low / denominator;
    214
                }
    215
    
                                                    
                                                
    216
                // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
    217
                if (denominator <= high) {
    218
                    Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
    219
                }
    220
    
                                                    
                                                
    221
                ///////////////////////////////////////////////
    222
                // 512 by 256 division.
    223
                ///////////////////////////////////////////////
    224
    
                                                    
                                                
    225
                // Make division exact by subtracting the remainder from [high low].
    226
                uint256 remainder;
    227
                assembly ("memory-safe") {
    228
                    // Compute remainder using mulmod.
    229
                    remainder := mulmod(x, y, denominator)
    230
    
                                                    
                                                
    231
                    // Subtract 256 bit number from 512 bit number.
    232
                    high := sub(high, gt(remainder, low))
    233
                    low := sub(low, remainder)
    234
                }
    235
    
                                                    
                                                
    236
                // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
    237
                // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
    238
    
                                                    
                                                
    239
                uint256 twos = denominator & (0 - denominator);
    240
                assembly ("memory-safe") {
    241
                    // Divide denominator by twos.
    242
                    denominator := div(denominator, twos)
    243
    
                                                    
                                                
    244
                    // Divide [high low] by twos.
    245
                    low := div(low, twos)
    246
    
                                                    
                                                
    247
                    // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
    248
                    twos := add(div(sub(0, twos), twos), 1)
    249
                }
    250
    
                                                    
                                                
    251
                // Shift in bits from high into low.
    252
                low |= high * twos;
    253
    
                                                    
                                                
    254
                // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
    255
                // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
    256
                // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
    257
                uint256 inverse = (3 * denominator) ^ 2;
    258
    
                                                    
                                                
    259
                // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
    260
                // works in modular arithmetic, doubling the correct bits in each step.
    261
                inverse *= 2 - denominator * inverse; // inverse mod 2⁸
    262
                inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
    263
                inverse *= 2 - denominator * inverse; // inverse mod 2³²
    264
                inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
    265
                inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
    266
                inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
    267
    
                                                    
                                                
    268
                // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
    269
                // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
    270
                // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high
    271
                // is no longer required.
    272
                result = low * inverse;
    273
                return result;
    274
            }
    275
        }
    276
    
                                                    
                                                
    277
        /**
    278
         * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
    279
         */
    280
        function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
    281
            return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    282
        }
    283
    
                                                    
                                                
    284
        /**
    285
         * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.
    286
         */
    287
        function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {
    288
            unchecked {
    289
                (uint256 high, uint256 low) = mul512(x, y);
    290
                if (high >= 1 << n) {
    291
                    Panic.panic(Panic.UNDER_OVERFLOW);
    292
                }
    293
                return (high << (256 - n)) | (low >> n);
    294
            }
    295
        }
    296
    
                                                    
                                                
    297
        /**
    298
         * @dev Calculates x * y >> n with full precision, following the selected rounding direction.
    299
         */
    300
        function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {
    301
            return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);
    302
        }
    303
    
                                                    
                                                
    304
        /**
    305
         * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
    306
         *
    307
         * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
    308
         * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
    309
         *
    310
         * If the input value is not inversible, 0 is returned.
    311
         *
    312
         * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
    313
         * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
    314
         */
    315
        function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
    316
            unchecked {
    317
                if (n == 0) return 0;
    318
    
                                                    
                                                
    319
                // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
    320
                // Used to compute integers x and y such that: ax + ny = gcd(a, n).
    321
                // When the gcd is 1, then the inverse of a modulo n exists and it's x.
    322
                // ax + ny = 1
    323
                // ax = 1 + (-y)n
    324
                // ax ≡ 1 (mod n) # x is the inverse of a modulo n
    325
    
                                                    
                                                
    326
                // If the remainder is 0 the gcd is n right away.
    327
                uint256 remainder = a % n;
    328
                uint256 gcd = n;
    329
    
                                                    
                                                
    330
                // Therefore the initial coefficients are:
    331
                // ax + ny = gcd(a, n) = n
    332
                // 0a + 1n = n
    333
                int256 x = 0;
    334
                int256 y = 1;
    335
    
                                                    
                                                
    336
                while (remainder != 0) {
    337
                    uint256 quotient = gcd / remainder;
    338
    
                                                    
                                                
    339
                    (gcd, remainder) = (
    340
                        // The old remainder is the next gcd to try.
    341
                        remainder,
    342
                        // Compute the next remainder.
    343
                        // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
    344
                        // where gcd is at most n (capped to type(uint256).max)
    345
                        gcd - remainder * quotient
    346
                    );
    347
    
                                                    
                                                
    348
                    (x, y) = (
    349
                        // Increment the coefficient of a.
    350
                        y,
    351
                        // Decrement the coefficient of n.
    352
                        // Can overflow, but the result is casted to uint256 so that the
    353
                        // next value of y is "wrapped around" to a value between 0 and n - 1.
    354
                        x - y * int256(quotient)
    355
                    );
    356
                }
    357
    
                                                    
                                                
    358
                if (gcd != 1) return 0; // No inverse exists.
    359
                return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
    360
            }
    361
        }
    362
    
                                                    
                                                
    363
        /**
    364
         * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
    365
         *
    366
         * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
    367
         * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
    368
         * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
    369
         *
    370
         * NOTE: this function does NOT check that `p` is a prime greater than `2`.
    371
         */
    372
        function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
    373
            unchecked {
    374
                return Math.modExp(a, p - 2, p);
    375
            }
    376
        }
    377
    
                                                    
                                                
    378
        /**
    379
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
    380
         *
    381
         * Requirements:
    382
         * - modulus can't be zero
    383
         * - underlying staticcall to precompile must succeed
    384
         *
    385
         * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
    386
         * sure the chain you're using it on supports the precompiled contract for modular exponentiation
    387
         * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
    388
         * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
    389
         * interpreted as 0.
    390
         */
    391
        function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
    392
            (bool success, uint256 result) = tryModExp(b, e, m);
    393
            if (!success) {
    394
                Panic.panic(Panic.DIVISION_BY_ZERO);
    395
            }
    396
            return result;
    397
        }
    398
    
                                                    
                                                
    399
        /**
    400
         * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
    401
         * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
    402
         * to operate modulo 0 or if the underlying precompile reverted.
    403
         *
    404
         * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
    405
         * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
    406
         * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
    407
         * of a revert, but the result may be incorrectly interpreted as 0.
    408
         */
    409
        function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
    410
            if (m == 0) return (false, 0);
    411
            assembly ("memory-safe") {
    412
                let ptr := mload(0x40)
    413
                // | Offset    | Content    | Content (Hex)                                                      |
    414
                // |-----------|------------|--------------------------------------------------------------------|
    415
                // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
    416
                // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
    417
                // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
    418
                // | 0x60:0x7f | value of b | 0x<.............................................................b> |
    419
                // | 0x80:0x9f | value of e | 0x<.............................................................e> |
    420
                // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
    421
                mstore(ptr, 0x20)
    422
                mstore(add(ptr, 0x20), 0x20)
    423
                mstore(add(ptr, 0x40), 0x20)
    424
                mstore(add(ptr, 0x60), b)
    425
                mstore(add(ptr, 0x80), e)
    426
                mstore(add(ptr, 0xa0), m)
    427
    
                                                    
                                                
    428
                // Given the result < m, it's guaranteed to fit in 32 bytes,
    429
                // so we can use the memory scratch space located at offset 0.
    430
                success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
    431
                result := mload(0x00)
    432
            }
    433
        }
    434
    
                                                    
                                                
    435
        /**
    436
         * @dev Variant of {modExp} that supports inputs of arbitrary length.
    437
         */
    438
        function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
    439
            (bool success, bytes memory result) = tryModExp(b, e, m);
    440
            if (!success) {
    441
                Panic.panic(Panic.DIVISION_BY_ZERO);
    442
            }
    443
            return result;
    444
        }
    445
    
                                                    
                                                
    446
        /**
    447
         * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
    448
         */
    449
        function tryModExp(
    450
            bytes memory b,
    451
            bytes memory e,
    452
            bytes memory m
    453
        ) internal view returns (bool success, bytes memory result) {
    454
            if (_zeroBytes(m)) return (false, new bytes(0));
    455
    
                                                    
                                                
    456
            uint256 mLen = m.length;
    457
    
                                                    
                                                
    458
            // Encode call args in result and move the free memory pointer
    459
            result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
    460
    
                                                    
                                                
    461
            assembly ("memory-safe") {
    462
                let dataPtr := add(result, 0x20)
    463
                // Write result on top of args to avoid allocating extra memory.
    464
                success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
    465
                // Overwrite the length.
    466
                // result.length > returndatasize() is guaranteed because returndatasize() == m.length
    467
                mstore(result, mLen)
    468
                // Set the memory pointer after the returned data.
    469
                mstore(0x40, add(dataPtr, mLen))
    470
            }
    471
        }
    472
    
                                                    
                                                
    473
        /**
    474
         * @dev Returns whether the provided byte array is zero.
    475
         */
    476
        function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
    477
            for (uint256 i = 0; i < byteArray.length; ++i) {
    478
                if (byteArray[i] != 0) {
    479
                    return false;
    480
                }
    481
            }
    482
            return true;
    483
        }
    484
    
                                                    
                                                
    485
        /**
    486
         * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
    487
         * towards zero.
    488
         *
    489
         * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
    490
         * using integer operations.
    491
         */
    492
        function sqrt(uint256 a) internal pure returns (uint256) {
    493
            unchecked {
    494
                // Take care of easy edge cases when a == 0 or a == 1
    495
                if (a <= 1) {
    496
                    return a;
    497
                }
    498
    
                                                    
                                                
    499
                // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
    500
                // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
    501
                // the current value as `ε_n = | x_n - sqrt(a) |`.
    502
                //
    503
                // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
    504
                // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
    505
                // bigger than any uint256.
    506
                //
    507
                // By noticing that
    508
                // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
    509
                // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
    510
                // to the msb function.
    511
                uint256 aa = a;
    512
                uint256 xn = 1;
    513
    
                                                    
                                                
    514
                if (aa >= (1 << 128)) {
    515
                    aa >>= 128;
    516
                    xn <<= 64;
    517
                }
    518
                if (aa >= (1 << 64)) {
    519
                    aa >>= 64;
    520
                    xn <<= 32;
    521
                }
    522
                if (aa >= (1 << 32)) {
    523
                    aa >>= 32;
    524
                    xn <<= 16;
    525
                }
    526
                if (aa >= (1 << 16)) {
    527
                    aa >>= 16;
    528
                    xn <<= 8;
    529
                }
    530
                if (aa >= (1 << 8)) {
    531
                    aa >>= 8;
    532
                    xn <<= 4;
    533
                }
    534
                if (aa >= (1 << 4)) {
    535
                    aa >>= 4;
    536
                    xn <<= 2;
    537
                }
    538
                if (aa >= (1 << 2)) {
    539
                    xn <<= 1;
    540
                }
    541
    
                                                    
                                                
    542
                // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
    543
                //
    544
                // We can refine our estimation by noticing that the middle of that interval minimizes the error.
    545
                // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
    546
                // This is going to be our x_0 (and ε_0)
    547
                xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
    548
    
                                                    
                                                
    549
                // From here, Newton's method give us:
    550
                // x_{n+1} = (x_n + a / x_n) / 2
    551
                //
    552
                // One should note that:
    553
                // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
    554
                //              = ((x_n² + a) / (2 * x_n))² - a
    555
                //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
    556
                //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
    557
                //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
    558
                //              = (x_n² - a)² / (2 * x_n)²
    559
                //              = ((x_n² - a) / (2 * x_n))²
    560
                //              ≥ 0
    561
                // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
    562
                //
    563
                // This gives us the proof of quadratic convergence of the sequence:
    564
                // ε_{n+1} = | x_{n+1} - sqrt(a) |
    565
                //         = | (x_n + a / x_n) / 2 - sqrt(a) |
    566
                //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
    567
                //         = | (x_n - sqrt(a))² / (2 * x_n) |
    568
                //         = | ε_n² / (2 * x_n) |
    569
                //         = ε_n² / | (2 * x_n) |
    570
                //
    571
                // For the first iteration, we have a special case where x_0 is known:
    572
                // ε_1 = ε_0² / | (2 * x_0) |
    573
                //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
    574
                //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
    575
                //     ≤ 2**(e-3) / 3
    576
                //     ≤ 2**(e-3-log2(3))
    577
                //     ≤ 2**(e-4.5)
    578
                //
    579
                // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
    580
                // ε_{n+1} = ε_n² / | (2 * x_n) |
    581
                //         ≤ (2**(e-k))² / (2 * 2**(e-1))
    582
                //         ≤ 2**(2*e-2*k) / 2**e
    583
                //         ≤ 2**(e-2*k)
    584
                xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
    585
                xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
    586
                xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
    587
                xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
    588
                xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
    589
                xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72
    590
    
                                                    
                                                
    591
                // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
    592
                // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
    593
                // sqrt(a) or sqrt(a) + 1.
    594
                return xn - SafeCast.toUint(xn > a / xn);
    595
            }
    596
        }
    597
    
                                                    
                                                
    598
        /**
    599
         * @dev Calculates sqrt(a), following the selected rounding direction.
    600
         */
    601
        function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
    602
            unchecked {
    603
                uint256 result = sqrt(a);
    604
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
    605
            }
    606
        }
    607
    
                                                    
                                                
    608
        /**
    609
         * @dev Return the log in base 2 of a positive value rounded towards zero.
    610
         * Returns 0 if given 0.
    611
         */
    612
        function log2(uint256 x) internal pure returns (uint256 r) {
    613
            // If value has upper 128 bits set, log2 result is at least 128
    614
            r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
    615
            // If upper 64 bits of 128-bit half set, add 64 to result
    616
            r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
    617
            // If upper 32 bits of 64-bit half set, add 32 to result
    618
            r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
    619
            // If upper 16 bits of 32-bit half set, add 16 to result
    620
            r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
    621
            // If upper 8 bits of 16-bit half set, add 8 to result
    622
            r |= SafeCast.toUint((x >> r) > 0xff) << 3;
    623
            // If upper 4 bits of 8-bit half set, add 4 to result
    624
            r |= SafeCast.toUint((x >> r) > 0xf) << 2;
    625
    
                                                    
                                                
    626
            // Shifts value right by the current result and use it as an index into this lookup table:
    627
            //
    628
            // | x (4 bits) |  index  | table[index] = MSB position |
    629
            // |------------|---------|-----------------------------|
    630
            // |    0000    |    0    |        table[0] = 0         |
    631
            // |    0001    |    1    |        table[1] = 0         |
    632
            // |    0010    |    2    |        table[2] = 1         |
    633
            // |    0011    |    3    |        table[3] = 1         |
    634
            // |    0100    |    4    |        table[4] = 2         |
    635
            // |    0101    |    5    |        table[5] = 2         |
    636
            // |    0110    |    6    |        table[6] = 2         |
    637
            // |    0111    |    7    |        table[7] = 2         |
    638
            // |    1000    |    8    |        table[8] = 3         |
    639
            // |    1001    |    9    |        table[9] = 3         |
    640
            // |    1010    |   10    |        table[10] = 3        |
    641
            // |    1011    |   11    |        table[11] = 3        |
    642
            // |    1100    |   12    |        table[12] = 3        |
    643
            // |    1101    |   13    |        table[13] = 3        |
    644
            // |    1110    |   14    |        table[14] = 3        |
    645
            // |    1111    |   15    |        table[15] = 3        |
    646
            //
    647
            // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
    648
            assembly ("memory-safe") {
    649
                r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
    650
            }
    651
        }
    652
    
                                                    
                                                
    653
        /**
    654
         * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
    655
         * Returns 0 if given 0.
    656
         */
    657
        function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
    658
            unchecked {
    659
                uint256 result = log2(value);
    660
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
    661
            }
    662
        }
    663
    
                                                    
                                                
    664
        /**
    665
         * @dev Return the log in base 10 of a positive value rounded towards zero.
    666
         * Returns 0 if given 0.
    667
         */
    668
        function log10(uint256 value) internal pure returns (uint256) {
    669
            uint256 result = 0;
    670
            unchecked {
    671
                if (value >= 10 ** 64) {
    672
                    value /= 10 ** 64;
    673
                    result += 64;
    674
                }
    675
                if (value >= 10 ** 32) {
    676
                    value /= 10 ** 32;
    677
                    result += 32;
    678
                }
    679
                if (value >= 10 ** 16) {
    680
                    value /= 10 ** 16;
    681
                    result += 16;
    682
                }
    683
                if (value >= 10 ** 8) {
    684
                    value /= 10 ** 8;
    685
                    result += 8;
    686
                }
    687
                if (value >= 10 ** 4) {
    688
                    value /= 10 ** 4;
    689
                    result += 4;
    690
                }
    691
                if (value >= 10 ** 2) {
    692
                    value /= 10 ** 2;
    693
                    result += 2;
    694
                }
    695
                if (value >= 10 ** 1) {
    696
                    result += 1;
    697
                }
    698
            }
    699
            return result;
    700
        }
    701
    
                                                    
                                                
    702
        /**
    703
         * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
    704
         * Returns 0 if given 0.
    705
         */
    706
        function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
    707
            unchecked {
    708
                uint256 result = log10(value);
    709
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
    710
            }
    711
        }
    712
    
                                                    
                                                
    713
        /**
    714
         * @dev Return the log in base 256 of a positive value rounded towards zero.
    715
         * Returns 0 if given 0.
    716
         *
    717
         * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
    718
         */
    719
        function log256(uint256 x) internal pure returns (uint256 r) {
    720
            // If value has upper 128 bits set, log2 result is at least 128
    721
            r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
    722
            // If upper 64 bits of 128-bit half set, add 64 to result
    723
            r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
    724
            // If upper 32 bits of 64-bit half set, add 32 to result
    725
            r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
    726
            // If upper 16 bits of 32-bit half set, add 16 to result
    727
            r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
    728
            // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8
    729
            return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);
    730
        }
    731
    
                                                    
                                                
    732
        /**
    733
         * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
    734
         * Returns 0 if given 0.
    735
         */
    736
        function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
    737
            unchecked {
    738
                uint256 result = log256(value);
    739
                return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
    740
            }
    741
        }
    742
    
                                                    
                                                
    743
        /**
    744
         * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
    745
         */
    746
        function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
    747
            return uint8(rounding) % 2 == 1;
    748
        }
    749
    }
    750
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
    3
    // This file was procedurally generated from scripts/generate/templates/SafeCast.js.
    4
    
                                                    
                                                
    5
    pragma solidity ^0.8.20;
    6
    
                                                    
                                                
    7
    /**
    8
     * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
    9
     * checks.
    10
     *
    11
     * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
    12
     * easily result in undesired exploitation or bugs, since developers usually
    13
     * assume that overflows raise errors. `SafeCast` restores this intuition by
    14
     * reverting the transaction when such an operation overflows.
    15
     *
    16
     * Using this library instead of the unchecked operations eliminates an entire
    17
     * class of bugs, so it's recommended to use it always.
    18
     */
    19
    ✓ 15
    library SafeCast {
    20
        /**
    21
         * @dev Value doesn't fit in an uint of `bits` size.
    22
         */
    23
        error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    24
    
                                                    
                                                
    25
        /**
    26
         * @dev An int value doesn't fit in an uint of `bits` size.
    27
         */
    28
        error SafeCastOverflowedIntToUint(int256 value);
    29
    
                                                    
                                                
    30
        /**
    31
         * @dev Value doesn't fit in an int of `bits` size.
    32
         */
    33
        error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
    34
    
                                                    
                                                
    35
        /**
    36
         * @dev An uint value doesn't fit in an int of `bits` size.
    37
         */
    38
        error SafeCastOverflowedUintToInt(uint256 value);
    39
    
                                                    
                                                
    40
        /**
    41
         * @dev Returns the downcasted uint248 from uint256, reverting on
    42
         * overflow (when the input is greater than largest uint248).
    43
         *
    44
         * Counterpart to Solidity's `uint248` operator.
    45
         *
    46
         * Requirements:
    47
         *
    48
         * - input must fit into 248 bits
    49
         */
    50
        function toUint248(uint256 value) internal pure returns (uint248) {
    51
            if (value > type(uint248).max) {
    52
                revert SafeCastOverflowedUintDowncast(248, value);
    53
            }
    54
            return uint248(value);
    55
        }
    56
    
                                                    
                                                
    57
        /**
    58
         * @dev Returns the downcasted uint240 from uint256, reverting on
    59
         * overflow (when the input is greater than largest uint240).
    60
         *
    61
         * Counterpart to Solidity's `uint240` operator.
    62
         *
    63
         * Requirements:
    64
         *
    65
         * - input must fit into 240 bits
    66
         */
    67
        function toUint240(uint256 value) internal pure returns (uint240) {
    68
            if (value > type(uint240).max) {
    69
                revert SafeCastOverflowedUintDowncast(240, value);
    70
            }
    71
            return uint240(value);
    72
        }
    73
    
                                                    
                                                
    74
        /**
    75
         * @dev Returns the downcasted uint232 from uint256, reverting on
    76
         * overflow (when the input is greater than largest uint232).
    77
         *
    78
         * Counterpart to Solidity's `uint232` operator.
    79
         *
    80
         * Requirements:
    81
         *
    82
         * - input must fit into 232 bits
    83
         */
    84
        function toUint232(uint256 value) internal pure returns (uint232) {
    85
            if (value > type(uint232).max) {
    86
                revert SafeCastOverflowedUintDowncast(232, value);
    87
            }
    88
            return uint232(value);
    89
        }
    90
    
                                                    
                                                
    91
        /**
    92
         * @dev Returns the downcasted uint224 from uint256, reverting on
    93
         * overflow (when the input is greater than largest uint224).
    94
         *
    95
         * Counterpart to Solidity's `uint224` operator.
    96
         *
    97
         * Requirements:
    98
         *
    99
         * - input must fit into 224 bits
    100
         */
    101
        function toUint224(uint256 value) internal pure returns (uint224) {
    102
            if (value > type(uint224).max) {
    103
                revert SafeCastOverflowedUintDowncast(224, value);
    104
            }
    105
            return uint224(value);
    106
        }
    107
    
                                                    
                                                
    108
        /**
    109
         * @dev Returns the downcasted uint216 from uint256, reverting on
    110
         * overflow (when the input is greater than largest uint216).
    111
         *
    112
         * Counterpart to Solidity's `uint216` operator.
    113
         *
    114
         * Requirements:
    115
         *
    116
         * - input must fit into 216 bits
    117
         */
    118
        function toUint216(uint256 value) internal pure returns (uint216) {
    119
            if (value > type(uint216).max) {
    120
                revert SafeCastOverflowedUintDowncast(216, value);
    121
            }
    122
            return uint216(value);
    123
        }
    124
    
                                                    
                                                
    125
        /**
    126
         * @dev Returns the downcasted uint208 from uint256, reverting on
    127
         * overflow (when the input is greater than largest uint208).
    128
         *
    129
         * Counterpart to Solidity's `uint208` operator.
    130
         *
    131
         * Requirements:
    132
         *
    133
         * - input must fit into 208 bits
    134
         */
    135
        function toUint208(uint256 value) internal pure returns (uint208) {
    136
            if (value > type(uint208).max) {
    137
                revert SafeCastOverflowedUintDowncast(208, value);
    138
            }
    139
            return uint208(value);
    140
        }
    141
    
                                                    
                                                
    142
        /**
    143
         * @dev Returns the downcasted uint200 from uint256, reverting on
    144
         * overflow (when the input is greater than largest uint200).
    145
         *
    146
         * Counterpart to Solidity's `uint200` operator.
    147
         *
    148
         * Requirements:
    149
         *
    150
         * - input must fit into 200 bits
    151
         */
    152
        function toUint200(uint256 value) internal pure returns (uint200) {
    153
            if (value > type(uint200).max) {
    154
                revert SafeCastOverflowedUintDowncast(200, value);
    155
            }
    156
            return uint200(value);
    157
        }
    158
    
                                                    
                                                
    159
        /**
    160
         * @dev Returns the downcasted uint192 from uint256, reverting on
    161
         * overflow (when the input is greater than largest uint192).
    162
         *
    163
         * Counterpart to Solidity's `uint192` operator.
    164
         *
    165
         * Requirements:
    166
         *
    167
         * - input must fit into 192 bits
    168
         */
    169
        function toUint192(uint256 value) internal pure returns (uint192) {
    170
            if (value > type(uint192).max) {
    171
                revert SafeCastOverflowedUintDowncast(192, value);
    172
            }
    173
            return uint192(value);
    174
        }
    175
    
                                                    
                                                
    176
        /**
    177
         * @dev Returns the downcasted uint184 from uint256, reverting on
    178
         * overflow (when the input is greater than largest uint184).
    179
         *
    180
         * Counterpart to Solidity's `uint184` operator.
    181
         *
    182
         * Requirements:
    183
         *
    184
         * - input must fit into 184 bits
    185
         */
    186
        function toUint184(uint256 value) internal pure returns (uint184) {
    187
            if (value > type(uint184).max) {
    188
                revert SafeCastOverflowedUintDowncast(184, value);
    189
            }
    190
            return uint184(value);
    191
        }
    192
    
                                                    
                                                
    193
        /**
    194
         * @dev Returns the downcasted uint176 from uint256, reverting on
    195
         * overflow (when the input is greater than largest uint176).
    196
         *
    197
         * Counterpart to Solidity's `uint176` operator.
    198
         *
    199
         * Requirements:
    200
         *
    201
         * - input must fit into 176 bits
    202
         */
    203
        function toUint176(uint256 value) internal pure returns (uint176) {
    204
            if (value > type(uint176).max) {
    205
                revert SafeCastOverflowedUintDowncast(176, value);
    206
            }
    207
            return uint176(value);
    208
        }
    209
    
                                                    
                                                
    210
        /**
    211
         * @dev Returns the downcasted uint168 from uint256, reverting on
    212
         * overflow (when the input is greater than largest uint168).
    213
         *
    214
         * Counterpart to Solidity's `uint168` operator.
    215
         *
    216
         * Requirements:
    217
         *
    218
         * - input must fit into 168 bits
    219
         */
    220
        function toUint168(uint256 value) internal pure returns (uint168) {
    221
            if (value > type(uint168).max) {
    222
                revert SafeCastOverflowedUintDowncast(168, value);
    223
            }
    224
            return uint168(value);
    225
        }
    226
    
                                                    
                                                
    227
        /**
    228
         * @dev Returns the downcasted uint160 from uint256, reverting on
    229
         * overflow (when the input is greater than largest uint160).
    230
         *
    231
         * Counterpart to Solidity's `uint160` operator.
    232
         *
    233
         * Requirements:
    234
         *
    235
         * - input must fit into 160 bits
    236
         */
    237
        function toUint160(uint256 value) internal pure returns (uint160) {
    238
            if (value > type(uint160).max) {
    239
                revert SafeCastOverflowedUintDowncast(160, value);
    240
            }
    241
            return uint160(value);
    242
        }
    243
    
                                                    
                                                
    244
        /**
    245
         * @dev Returns the downcasted uint152 from uint256, reverting on
    246
         * overflow (when the input is greater than largest uint152).
    247
         *
    248
         * Counterpart to Solidity's `uint152` operator.
    249
         *
    250
         * Requirements:
    251
         *
    252
         * - input must fit into 152 bits
    253
         */
    254
        function toUint152(uint256 value) internal pure returns (uint152) {
    255
            if (value > type(uint152).max) {
    256
                revert SafeCastOverflowedUintDowncast(152, value);
    257
            }
    258
            return uint152(value);
    259
        }
    260
    
                                                    
                                                
    261
        /**
    262
         * @dev Returns the downcasted uint144 from uint256, reverting on
    263
         * overflow (when the input is greater than largest uint144).
    264
         *
    265
         * Counterpart to Solidity's `uint144` operator.
    266
         *
    267
         * Requirements:
    268
         *
    269
         * - input must fit into 144 bits
    270
         */
    271
        function toUint144(uint256 value) internal pure returns (uint144) {
    272
            if (value > type(uint144).max) {
    273
                revert SafeCastOverflowedUintDowncast(144, value);
    274
            }
    275
            return uint144(value);
    276
        }
    277
    
                                                    
                                                
    278
        /**
    279
         * @dev Returns the downcasted uint136 from uint256, reverting on
    280
         * overflow (when the input is greater than largest uint136).
    281
         *
    282
         * Counterpart to Solidity's `uint136` operator.
    283
         *
    284
         * Requirements:
    285
         *
    286
         * - input must fit into 136 bits
    287
         */
    288
        function toUint136(uint256 value) internal pure returns (uint136) {
    289
            if (value > type(uint136).max) {
    290
                revert SafeCastOverflowedUintDowncast(136, value);
    291
            }
    292
            return uint136(value);
    293
        }
    294
    
                                                    
                                                
    295
        /**
    296
         * @dev Returns the downcasted uint128 from uint256, reverting on
    297
         * overflow (when the input is greater than largest uint128).
    298
         *
    299
         * Counterpart to Solidity's `uint128` operator.
    300
         *
    301
         * Requirements:
    302
         *
    303
         * - input must fit into 128 bits
    304
         */
    305
        function toUint128(uint256 value) internal pure returns (uint128) {
    306
            if (value > type(uint128).max) {
    307
                revert SafeCastOverflowedUintDowncast(128, value);
    308
            }
    309
            return uint128(value);
    310
        }
    311
    
                                                    
                                                
    312
        /**
    313
         * @dev Returns the downcasted uint120 from uint256, reverting on
    314
         * overflow (when the input is greater than largest uint120).
    315
         *
    316
         * Counterpart to Solidity's `uint120` operator.
    317
         *
    318
         * Requirements:
    319
         *
    320
         * - input must fit into 120 bits
    321
         */
    322
        function toUint120(uint256 value) internal pure returns (uint120) {
    323
            if (value > type(uint120).max) {
    324
                revert SafeCastOverflowedUintDowncast(120, value);
    325
            }
    326
            return uint120(value);
    327
        }
    328
    
                                                    
                                                
    329
        /**
    330
         * @dev Returns the downcasted uint112 from uint256, reverting on
    331
         * overflow (when the input is greater than largest uint112).
    332
         *
    333
         * Counterpart to Solidity's `uint112` operator.
    334
         *
    335
         * Requirements:
    336
         *
    337
         * - input must fit into 112 bits
    338
         */
    339
        function toUint112(uint256 value) internal pure returns (uint112) {
    340
            if (value > type(uint112).max) {
    341
                revert SafeCastOverflowedUintDowncast(112, value);
    342
            }
    343
            return uint112(value);
    344
        }
    345
    
                                                    
                                                
    346
        /**
    347
         * @dev Returns the downcasted uint104 from uint256, reverting on
    348
         * overflow (when the input is greater than largest uint104).
    349
         *
    350
         * Counterpart to Solidity's `uint104` operator.
    351
         *
    352
         * Requirements:
    353
         *
    354
         * - input must fit into 104 bits
    355
         */
    356
        function toUint104(uint256 value) internal pure returns (uint104) {
    357
            if (value > type(uint104).max) {
    358
                revert SafeCastOverflowedUintDowncast(104, value);
    359
            }
    360
            return uint104(value);
    361
        }
    362
    
                                                    
                                                
    363
        /**
    364
         * @dev Returns the downcasted uint96 from uint256, reverting on
    365
         * overflow (when the input is greater than largest uint96).
    366
         *
    367
         * Counterpart to Solidity's `uint96` operator.
    368
         *
    369
         * Requirements:
    370
         *
    371
         * - input must fit into 96 bits
    372
         */
    373
        function toUint96(uint256 value) internal pure returns (uint96) {
    374
            if (value > type(uint96).max) {
    375
                revert SafeCastOverflowedUintDowncast(96, value);
    376
            }
    377
            return uint96(value);
    378
        }
    379
    
                                                    
                                                
    380
        /**
    381
         * @dev Returns the downcasted uint88 from uint256, reverting on
    382
         * overflow (when the input is greater than largest uint88).
    383
         *
    384
         * Counterpart to Solidity's `uint88` operator.
    385
         *
    386
         * Requirements:
    387
         *
    388
         * - input must fit into 88 bits
    389
         */
    390
        function toUint88(uint256 value) internal pure returns (uint88) {
    391
            if (value > type(uint88).max) {
    392
                revert SafeCastOverflowedUintDowncast(88, value);
    393
            }
    394
            return uint88(value);
    395
        }
    396
    
                                                    
                                                
    397
        /**
    398
         * @dev Returns the downcasted uint80 from uint256, reverting on
    399
         * overflow (when the input is greater than largest uint80).
    400
         *
    401
         * Counterpart to Solidity's `uint80` operator.
    402
         *
    403
         * Requirements:
    404
         *
    405
         * - input must fit into 80 bits
    406
         */
    407
        function toUint80(uint256 value) internal pure returns (uint80) {
    408
            if (value > type(uint80).max) {
    409
                revert SafeCastOverflowedUintDowncast(80, value);
    410
            }
    411
            return uint80(value);
    412
        }
    413
    
                                                    
                                                
    414
        /**
    415
         * @dev Returns the downcasted uint72 from uint256, reverting on
    416
         * overflow (when the input is greater than largest uint72).
    417
         *
    418
         * Counterpart to Solidity's `uint72` operator.
    419
         *
    420
         * Requirements:
    421
         *
    422
         * - input must fit into 72 bits
    423
         */
    424
        function toUint72(uint256 value) internal pure returns (uint72) {
    425
            if (value > type(uint72).max) {
    426
                revert SafeCastOverflowedUintDowncast(72, value);
    427
            }
    428
            return uint72(value);
    429
        }
    430
    
                                                    
                                                
    431
        /**
    432
         * @dev Returns the downcasted uint64 from uint256, reverting on
    433
         * overflow (when the input is greater than largest uint64).
    434
         *
    435
         * Counterpart to Solidity's `uint64` operator.
    436
         *
    437
         * Requirements:
    438
         *
    439
         * - input must fit into 64 bits
    440
         */
    441
        function toUint64(uint256 value) internal pure returns (uint64) {
    442
            if (value > type(uint64).max) {
    443
                revert SafeCastOverflowedUintDowncast(64, value);
    444
            }
    445
            return uint64(value);
    446
        }
    447
    
                                                    
                                                
    448
        /**
    449
         * @dev Returns the downcasted uint56 from uint256, reverting on
    450
         * overflow (when the input is greater than largest uint56).
    451
         *
    452
         * Counterpart to Solidity's `uint56` operator.
    453
         *
    454
         * Requirements:
    455
         *
    456
         * - input must fit into 56 bits
    457
         */
    458
        function toUint56(uint256 value) internal pure returns (uint56) {
    459
            if (value > type(uint56).max) {
    460
                revert SafeCastOverflowedUintDowncast(56, value);
    461
            }
    462
            return uint56(value);
    463
        }
    464
    
                                                    
                                                
    465
        /**
    466
         * @dev Returns the downcasted uint48 from uint256, reverting on
    467
         * overflow (when the input is greater than largest uint48).
    468
         *
    469
         * Counterpart to Solidity's `uint48` operator.
    470
         *
    471
         * Requirements:
    472
         *
    473
         * - input must fit into 48 bits
    474
         */
    475
        function toUint48(uint256 value) internal pure returns (uint48) {
    476
            if (value > type(uint48).max) {
    477
                revert SafeCastOverflowedUintDowncast(48, value);
    478
            }
    479
            return uint48(value);
    480
        }
    481
    
                                                    
                                                
    482
        /**
    483
         * @dev Returns the downcasted uint40 from uint256, reverting on
    484
         * overflow (when the input is greater than largest uint40).
    485
         *
    486
         * Counterpart to Solidity's `uint40` operator.
    487
         *
    488
         * Requirements:
    489
         *
    490
         * - input must fit into 40 bits
    491
         */
    492
        function toUint40(uint256 value) internal pure returns (uint40) {
    493
            if (value > type(uint40).max) {
    494
                revert SafeCastOverflowedUintDowncast(40, value);
    495
            }
    496
            return uint40(value);
    497
        }
    498
    
                                                    
                                                
    499
        /**
    500
         * @dev Returns the downcasted uint32 from uint256, reverting on
    501
         * overflow (when the input is greater than largest uint32).
    502
         *
    503
         * Counterpart to Solidity's `uint32` operator.
    504
         *
    505
         * Requirements:
    506
         *
    507
         * - input must fit into 32 bits
    508
         */
    509
        function toUint32(uint256 value) internal pure returns (uint32) {
    510
            if (value > type(uint32).max) {
    511
                revert SafeCastOverflowedUintDowncast(32, value);
    512
            }
    513
            return uint32(value);
    514
        }
    515
    
                                                    
                                                
    516
        /**
    517
         * @dev Returns the downcasted uint24 from uint256, reverting on
    518
         * overflow (when the input is greater than largest uint24).
    519
         *
    520
         * Counterpart to Solidity's `uint24` operator.
    521
         *
    522
         * Requirements:
    523
         *
    524
         * - input must fit into 24 bits
    525
         */
    526
        function toUint24(uint256 value) internal pure returns (uint24) {
    527
            if (value > type(uint24).max) {
    528
                revert SafeCastOverflowedUintDowncast(24, value);
    529
            }
    530
            return uint24(value);
    531
        }
    532
    
                                                    
                                                
    533
        /**
    534
         * @dev Returns the downcasted uint16 from uint256, reverting on
    535
         * overflow (when the input is greater than largest uint16).
    536
         *
    537
         * Counterpart to Solidity's `uint16` operator.
    538
         *
    539
         * Requirements:
    540
         *
    541
         * - input must fit into 16 bits
    542
         */
    543
        function toUint16(uint256 value) internal pure returns (uint16) {
    544
            if (value > type(uint16).max) {
    545
                revert SafeCastOverflowedUintDowncast(16, value);
    546
            }
    547
            return uint16(value);
    548
        }
    549
    
                                                    
                                                
    550
        /**
    551
         * @dev Returns the downcasted uint8 from uint256, reverting on
    552
         * overflow (when the input is greater than largest uint8).
    553
         *
    554
         * Counterpart to Solidity's `uint8` operator.
    555
         *
    556
         * Requirements:
    557
         *
    558
         * - input must fit into 8 bits
    559
         */
    560
        function toUint8(uint256 value) internal pure returns (uint8) {
    561
            if (value > type(uint8).max) {
    562
                revert SafeCastOverflowedUintDowncast(8, value);
    563
            }
    564
            return uint8(value);
    565
        }
    566
    
                                                    
                                                
    567
        /**
    568
         * @dev Converts a signed int256 into an unsigned uint256.
    569
         *
    570
         * Requirements:
    571
         *
    572
         * - input must be greater than or equal to 0.
    573
         */
    574
        function toUint256(int256 value) internal pure returns (uint256) {
    575
            if (value < 0) {
    576
                revert SafeCastOverflowedIntToUint(value);
    577
            }
    578
            return uint256(value);
    579
        }
    580
    
                                                    
                                                
    581
        /**
    582
         * @dev Returns the downcasted int248 from int256, reverting on
    583
         * overflow (when the input is less than smallest int248 or
    584
         * greater than largest int248).
    585
         *
    586
         * Counterpart to Solidity's `int248` operator.
    587
         *
    588
         * Requirements:
    589
         *
    590
         * - input must fit into 248 bits
    591
         */
    592
        function toInt248(int256 value) internal pure returns (int248 downcasted) {
    593
            downcasted = int248(value);
    594
            if (downcasted != value) {
    595
                revert SafeCastOverflowedIntDowncast(248, value);
    596
            }
    597
        }
    598
    
                                                    
                                                
    599
        /**
    600
         * @dev Returns the downcasted int240 from int256, reverting on
    601
         * overflow (when the input is less than smallest int240 or
    602
         * greater than largest int240).
    603
         *
    604
         * Counterpart to Solidity's `int240` operator.
    605
         *
    606
         * Requirements:
    607
         *
    608
         * - input must fit into 240 bits
    609
         */
    610
        function toInt240(int256 value) internal pure returns (int240 downcasted) {
    611
            downcasted = int240(value);
    612
            if (downcasted != value) {
    613
                revert SafeCastOverflowedIntDowncast(240, value);
    614
            }
    615
        }
    616
    
                                                    
                                                
    617
        /**
    618
         * @dev Returns the downcasted int232 from int256, reverting on
    619
         * overflow (when the input is less than smallest int232 or
    620
         * greater than largest int232).
    621
         *
    622
         * Counterpart to Solidity's `int232` operator.
    623
         *
    624
         * Requirements:
    625
         *
    626
         * - input must fit into 232 bits
    627
         */
    628
        function toInt232(int256 value) internal pure returns (int232 downcasted) {
    629
            downcasted = int232(value);
    630
            if (downcasted != value) {
    631
                revert SafeCastOverflowedIntDowncast(232, value);
    632
            }
    633
        }
    634
    
                                                    
                                                
    635
        /**
    636
         * @dev Returns the downcasted int224 from int256, reverting on
    637
         * overflow (when the input is less than smallest int224 or
    638
         * greater than largest int224).
    639
         *
    640
         * Counterpart to Solidity's `int224` operator.
    641
         *
    642
         * Requirements:
    643
         *
    644
         * - input must fit into 224 bits
    645
         */
    646
        function toInt224(int256 value) internal pure returns (int224 downcasted) {
    647
            downcasted = int224(value);
    648
            if (downcasted != value) {
    649
                revert SafeCastOverflowedIntDowncast(224, value);
    650
            }
    651
        }
    652
    
                                                    
                                                
    653
        /**
    654
         * @dev Returns the downcasted int216 from int256, reverting on
    655
         * overflow (when the input is less than smallest int216 or
    656
         * greater than largest int216).
    657
         *
    658
         * Counterpart to Solidity's `int216` operator.
    659
         *
    660
         * Requirements:
    661
         *
    662
         * - input must fit into 216 bits
    663
         */
    664
        function toInt216(int256 value) internal pure returns (int216 downcasted) {
    665
            downcasted = int216(value);
    666
            if (downcasted != value) {
    667
                revert SafeCastOverflowedIntDowncast(216, value);
    668
            }
    669
        }
    670
    
                                                    
                                                
    671
        /**
    672
         * @dev Returns the downcasted int208 from int256, reverting on
    673
         * overflow (when the input is less than smallest int208 or
    674
         * greater than largest int208).
    675
         *
    676
         * Counterpart to Solidity's `int208` operator.
    677
         *
    678
         * Requirements:
    679
         *
    680
         * - input must fit into 208 bits
    681
         */
    682
        function toInt208(int256 value) internal pure returns (int208 downcasted) {
    683
            downcasted = int208(value);
    684
            if (downcasted != value) {
    685
                revert SafeCastOverflowedIntDowncast(208, value);
    686
            }
    687
        }
    688
    
                                                    
                                                
    689
        /**
    690
         * @dev Returns the downcasted int200 from int256, reverting on
    691
         * overflow (when the input is less than smallest int200 or
    692
         * greater than largest int200).
    693
         *
    694
         * Counterpart to Solidity's `int200` operator.
    695
         *
    696
         * Requirements:
    697
         *
    698
         * - input must fit into 200 bits
    699
         */
    700
        function toInt200(int256 value) internal pure returns (int200 downcasted) {
    701
            downcasted = int200(value);
    702
            if (downcasted != value) {
    703
                revert SafeCastOverflowedIntDowncast(200, value);
    704
            }
    705
        }
    706
    
                                                    
                                                
    707
        /**
    708
         * @dev Returns the downcasted int192 from int256, reverting on
    709
         * overflow (when the input is less than smallest int192 or
    710
         * greater than largest int192).
    711
         *
    712
         * Counterpart to Solidity's `int192` operator.
    713
         *
    714
         * Requirements:
    715
         *
    716
         * - input must fit into 192 bits
    717
         */
    718
        function toInt192(int256 value) internal pure returns (int192 downcasted) {
    719
            downcasted = int192(value);
    720
            if (downcasted != value) {
    721
                revert SafeCastOverflowedIntDowncast(192, value);
    722
            }
    723
        }
    724
    
                                                    
                                                
    725
        /**
    726
         * @dev Returns the downcasted int184 from int256, reverting on
    727
         * overflow (when the input is less than smallest int184 or
    728
         * greater than largest int184).
    729
         *
    730
         * Counterpart to Solidity's `int184` operator.
    731
         *
    732
         * Requirements:
    733
         *
    734
         * - input must fit into 184 bits
    735
         */
    736
        function toInt184(int256 value) internal pure returns (int184 downcasted) {
    737
            downcasted = int184(value);
    738
            if (downcasted != value) {
    739
                revert SafeCastOverflowedIntDowncast(184, value);
    740
            }
    741
        }
    742
    
                                                    
                                                
    743
        /**
    744
         * @dev Returns the downcasted int176 from int256, reverting on
    745
         * overflow (when the input is less than smallest int176 or
    746
         * greater than largest int176).
    747
         *
    748
         * Counterpart to Solidity's `int176` operator.
    749
         *
    750
         * Requirements:
    751
         *
    752
         * - input must fit into 176 bits
    753
         */
    754
        function toInt176(int256 value) internal pure returns (int176 downcasted) {
    755
            downcasted = int176(value);
    756
            if (downcasted != value) {
    757
                revert SafeCastOverflowedIntDowncast(176, value);
    758
            }
    759
        }
    760
    
                                                    
                                                
    761
        /**
    762
         * @dev Returns the downcasted int168 from int256, reverting on
    763
         * overflow (when the input is less than smallest int168 or
    764
         * greater than largest int168).
    765
         *
    766
         * Counterpart to Solidity's `int168` operator.
    767
         *
    768
         * Requirements:
    769
         *
    770
         * - input must fit into 168 bits
    771
         */
    772
        function toInt168(int256 value) internal pure returns (int168 downcasted) {
    773
            downcasted = int168(value);
    774
            if (downcasted != value) {
    775
                revert SafeCastOverflowedIntDowncast(168, value);
    776
            }
    777
        }
    778
    
                                                    
                                                
    779
        /**
    780
         * @dev Returns the downcasted int160 from int256, reverting on
    781
         * overflow (when the input is less than smallest int160 or
    782
         * greater than largest int160).
    783
         *
    784
         * Counterpart to Solidity's `int160` operator.
    785
         *
    786
         * Requirements:
    787
         *
    788
         * - input must fit into 160 bits
    789
         */
    790
        function toInt160(int256 value) internal pure returns (int160 downcasted) {
    791
            downcasted = int160(value);
    792
            if (downcasted != value) {
    793
                revert SafeCastOverflowedIntDowncast(160, value);
    794
            }
    795
        }
    796
    
                                                    
                                                
    797
        /**
    798
         * @dev Returns the downcasted int152 from int256, reverting on
    799
         * overflow (when the input is less than smallest int152 or
    800
         * greater than largest int152).
    801
         *
    802
         * Counterpart to Solidity's `int152` operator.
    803
         *
    804
         * Requirements:
    805
         *
    806
         * - input must fit into 152 bits
    807
         */
    808
        function toInt152(int256 value) internal pure returns (int152 downcasted) {
    809
            downcasted = int152(value);
    810
            if (downcasted != value) {
    811
                revert SafeCastOverflowedIntDowncast(152, value);
    812
            }
    813
        }
    814
    
                                                    
                                                
    815
        /**
    816
         * @dev Returns the downcasted int144 from int256, reverting on
    817
         * overflow (when the input is less than smallest int144 or
    818
         * greater than largest int144).
    819
         *
    820
         * Counterpart to Solidity's `int144` operator.
    821
         *
    822
         * Requirements:
    823
         *
    824
         * - input must fit into 144 bits
    825
         */
    826
        function toInt144(int256 value) internal pure returns (int144 downcasted) {
    827
            downcasted = int144(value);
    828
            if (downcasted != value) {
    829
                revert SafeCastOverflowedIntDowncast(144, value);
    830
            }
    831
        }
    832
    
                                                    
                                                
    833
        /**
    834
         * @dev Returns the downcasted int136 from int256, reverting on
    835
         * overflow (when the input is less than smallest int136 or
    836
         * greater than largest int136).
    837
         *
    838
         * Counterpart to Solidity's `int136` operator.
    839
         *
    840
         * Requirements:
    841
         *
    842
         * - input must fit into 136 bits
    843
         */
    844
        function toInt136(int256 value) internal pure returns (int136 downcasted) {
    845
            downcasted = int136(value);
    846
            if (downcasted != value) {
    847
                revert SafeCastOverflowedIntDowncast(136, value);
    848
            }
    849
        }
    850
    
                                                    
                                                
    851
        /**
    852
         * @dev Returns the downcasted int128 from int256, reverting on
    853
         * overflow (when the input is less than smallest int128 or
    854
         * greater than largest int128).
    855
         *
    856
         * Counterpart to Solidity's `int128` operator.
    857
         *
    858
         * Requirements:
    859
         *
    860
         * - input must fit into 128 bits
    861
         */
    862
        function toInt128(int256 value) internal pure returns (int128 downcasted) {
    863
            downcasted = int128(value);
    864
            if (downcasted != value) {
    865
                revert SafeCastOverflowedIntDowncast(128, value);
    866
            }
    867
        }
    868
    
                                                    
                                                
    869
        /**
    870
         * @dev Returns the downcasted int120 from int256, reverting on
    871
         * overflow (when the input is less than smallest int120 or
    872
         * greater than largest int120).
    873
         *
    874
         * Counterpart to Solidity's `int120` operator.
    875
         *
    876
         * Requirements:
    877
         *
    878
         * - input must fit into 120 bits
    879
         */
    880
        function toInt120(int256 value) internal pure returns (int120 downcasted) {
    881
            downcasted = int120(value);
    882
            if (downcasted != value) {
    883
                revert SafeCastOverflowedIntDowncast(120, value);
    884
            }
    885
        }
    886
    
                                                    
                                                
    887
        /**
    888
         * @dev Returns the downcasted int112 from int256, reverting on
    889
         * overflow (when the input is less than smallest int112 or
    890
         * greater than largest int112).
    891
         *
    892
         * Counterpart to Solidity's `int112` operator.
    893
         *
    894
         * Requirements:
    895
         *
    896
         * - input must fit into 112 bits
    897
         */
    898
        function toInt112(int256 value) internal pure returns (int112 downcasted) {
    899
            downcasted = int112(value);
    900
            if (downcasted != value) {
    901
                revert SafeCastOverflowedIntDowncast(112, value);
    902
            }
    903
        }
    904
    
                                                    
                                                
    905
        /**
    906
         * @dev Returns the downcasted int104 from int256, reverting on
    907
         * overflow (when the input is less than smallest int104 or
    908
         * greater than largest int104).
    909
         *
    910
         * Counterpart to Solidity's `int104` operator.
    911
         *
    912
         * Requirements:
    913
         *
    914
         * - input must fit into 104 bits
    915
         */
    916
        function toInt104(int256 value) internal pure returns (int104 downcasted) {
    917
            downcasted = int104(value);
    918
            if (downcasted != value) {
    919
                revert SafeCastOverflowedIntDowncast(104, value);
    920
            }
    921
        }
    922
    
                                                    
                                                
    923
        /**
    924
         * @dev Returns the downcasted int96 from int256, reverting on
    925
         * overflow (when the input is less than smallest int96 or
    926
         * greater than largest int96).
    927
         *
    928
         * Counterpart to Solidity's `int96` operator.
    929
         *
    930
         * Requirements:
    931
         *
    932
         * - input must fit into 96 bits
    933
         */
    934
        function toInt96(int256 value) internal pure returns (int96 downcasted) {
    935
            downcasted = int96(value);
    936
            if (downcasted != value) {
    937
                revert SafeCastOverflowedIntDowncast(96, value);
    938
            }
    939
        }
    940
    
                                                    
                                                
    941
        /**
    942
         * @dev Returns the downcasted int88 from int256, reverting on
    943
         * overflow (when the input is less than smallest int88 or
    944
         * greater than largest int88).
    945
         *
    946
         * Counterpart to Solidity's `int88` operator.
    947
         *
    948
         * Requirements:
    949
         *
    950
         * - input must fit into 88 bits
    951
         */
    952
        function toInt88(int256 value) internal pure returns (int88 downcasted) {
    953
            downcasted = int88(value);
    954
            if (downcasted != value) {
    955
                revert SafeCastOverflowedIntDowncast(88, value);
    956
            }
    957
        }
    958
    
                                                    
                                                
    959
        /**
    960
         * @dev Returns the downcasted int80 from int256, reverting on
    961
         * overflow (when the input is less than smallest int80 or
    962
         * greater than largest int80).
    963
         *
    964
         * Counterpart to Solidity's `int80` operator.
    965
         *
    966
         * Requirements:
    967
         *
    968
         * - input must fit into 80 bits
    969
         */
    970
        function toInt80(int256 value) internal pure returns (int80 downcasted) {
    971
            downcasted = int80(value);
    972
            if (downcasted != value) {
    973
                revert SafeCastOverflowedIntDowncast(80, value);
    974
            }
    975
        }
    976
    
                                                    
                                                
    977
        /**
    978
         * @dev Returns the downcasted int72 from int256, reverting on
    979
         * overflow (when the input is less than smallest int72 or
    980
         * greater than largest int72).
    981
         *
    982
         * Counterpart to Solidity's `int72` operator.
    983
         *
    984
         * Requirements:
    985
         *
    986
         * - input must fit into 72 bits
    987
         */
    988
        function toInt72(int256 value) internal pure returns (int72 downcasted) {
    989
            downcasted = int72(value);
    990
            if (downcasted != value) {
    991
                revert SafeCastOverflowedIntDowncast(72, value);
    992
            }
    993
        }
    994
    
                                                    
                                                
    995
        /**
    996
         * @dev Returns the downcasted int64 from int256, reverting on
    997
         * overflow (when the input is less than smallest int64 or
    998
         * greater than largest int64).
    999
         *
    1000
         * Counterpart to Solidity's `int64` operator.
    1001
         *
    1002
         * Requirements:
    1003
         *
    1004
         * - input must fit into 64 bits
    1005
         */
    1006
        function toInt64(int256 value) internal pure returns (int64 downcasted) {
    1007
            downcasted = int64(value);
    1008
            if (downcasted != value) {
    1009
                revert SafeCastOverflowedIntDowncast(64, value);
    1010
            }
    1011
        }
    1012
    
                                                    
                                                
    1013
        /**
    1014
         * @dev Returns the downcasted int56 from int256, reverting on
    1015
         * overflow (when the input is less than smallest int56 or
    1016
         * greater than largest int56).
    1017
         *
    1018
         * Counterpart to Solidity's `int56` operator.
    1019
         *
    1020
         * Requirements:
    1021
         *
    1022
         * - input must fit into 56 bits
    1023
         */
    1024
        function toInt56(int256 value) internal pure returns (int56 downcasted) {
    1025
            downcasted = int56(value);
    1026
            if (downcasted != value) {
    1027
                revert SafeCastOverflowedIntDowncast(56, value);
    1028
            }
    1029
        }
    1030
    
                                                    
                                                
    1031
        /**
    1032
         * @dev Returns the downcasted int48 from int256, reverting on
    1033
         * overflow (when the input is less than smallest int48 or
    1034
         * greater than largest int48).
    1035
         *
    1036
         * Counterpart to Solidity's `int48` operator.
    1037
         *
    1038
         * Requirements:
    1039
         *
    1040
         * - input must fit into 48 bits
    1041
         */
    1042
        function toInt48(int256 value) internal pure returns (int48 downcasted) {
    1043
            downcasted = int48(value);
    1044
            if (downcasted != value) {
    1045
                revert SafeCastOverflowedIntDowncast(48, value);
    1046
            }
    1047
        }
    1048
    
                                                    
                                                
    1049
        /**
    1050
         * @dev Returns the downcasted int40 from int256, reverting on
    1051
         * overflow (when the input is less than smallest int40 or
    1052
         * greater than largest int40).
    1053
         *
    1054
         * Counterpart to Solidity's `int40` operator.
    1055
         *
    1056
         * Requirements:
    1057
         *
    1058
         * - input must fit into 40 bits
    1059
         */
    1060
        function toInt40(int256 value) internal pure returns (int40 downcasted) {
    1061
            downcasted = int40(value);
    1062
            if (downcasted != value) {
    1063
                revert SafeCastOverflowedIntDowncast(40, value);
    1064
            }
    1065
        }
    1066
    
                                                    
                                                
    1067
        /**
    1068
         * @dev Returns the downcasted int32 from int256, reverting on
    1069
         * overflow (when the input is less than smallest int32 or
    1070
         * greater than largest int32).
    1071
         *
    1072
         * Counterpart to Solidity's `int32` operator.
    1073
         *
    1074
         * Requirements:
    1075
         *
    1076
         * - input must fit into 32 bits
    1077
         */
    1078
        function toInt32(int256 value) internal pure returns (int32 downcasted) {
    1079
            downcasted = int32(value);
    1080
            if (downcasted != value) {
    1081
                revert SafeCastOverflowedIntDowncast(32, value);
    1082
            }
    1083
        }
    1084
    
                                                    
                                                
    1085
        /**
    1086
         * @dev Returns the downcasted int24 from int256, reverting on
    1087
         * overflow (when the input is less than smallest int24 or
    1088
         * greater than largest int24).
    1089
         *
    1090
         * Counterpart to Solidity's `int24` operator.
    1091
         *
    1092
         * Requirements:
    1093
         *
    1094
         * - input must fit into 24 bits
    1095
         */
    1096
        function toInt24(int256 value) internal pure returns (int24 downcasted) {
    1097
            downcasted = int24(value);
    1098
            if (downcasted != value) {
    1099
                revert SafeCastOverflowedIntDowncast(24, value);
    1100
            }
    1101
        }
    1102
    
                                                    
                                                
    1103
        /**
    1104
         * @dev Returns the downcasted int16 from int256, reverting on
    1105
         * overflow (when the input is less than smallest int16 or
    1106
         * greater than largest int16).
    1107
         *
    1108
         * Counterpart to Solidity's `int16` operator.
    1109
         *
    1110
         * Requirements:
    1111
         *
    1112
         * - input must fit into 16 bits
    1113
         */
    1114
        function toInt16(int256 value) internal pure returns (int16 downcasted) {
    1115
            downcasted = int16(value);
    1116
            if (downcasted != value) {
    1117
                revert SafeCastOverflowedIntDowncast(16, value);
    1118
            }
    1119
        }
    1120
    
                                                    
                                                
    1121
        /**
    1122
         * @dev Returns the downcasted int8 from int256, reverting on
    1123
         * overflow (when the input is less than smallest int8 or
    1124
         * greater than largest int8).
    1125
         *
    1126
         * Counterpart to Solidity's `int8` operator.
    1127
         *
    1128
         * Requirements:
    1129
         *
    1130
         * - input must fit into 8 bits
    1131
         */
    1132
        function toInt8(int256 value) internal pure returns (int8 downcasted) {
    1133
            downcasted = int8(value);
    1134
            if (downcasted != value) {
    1135
                revert SafeCastOverflowedIntDowncast(8, value);
    1136
            }
    1137
        }
    1138
    
                                                    
                                                
    1139
        /**
    1140
         * @dev Converts an unsigned uint256 into a signed int256.
    1141
         *
    1142
         * Requirements:
    1143
         *
    1144
         * - input must be less than or equal to maxInt256.
    1145
         */
    1146
        function toInt256(uint256 value) internal pure returns (int256) {
    1147
            // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
    1148
            if (value > uint256(type(int256).max)) {
    1149
                revert SafeCastOverflowedUintToInt(value);
    1150
            }
    1151
            return int256(value);
    1152
        }
    1153
    
                                                    
                                                
    1154
        /**
    1155
         * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
    1156
         */
    1157
        function toUint(bool b) internal pure returns (uint256 u) {
    1158
            assembly ("memory-safe") {
    1159
                u := iszero(iszero(b))
    1160
            }
    1161
        }
    1162
    }
    1163
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)
    3
    
                                                    
                                                
    4
    pragma solidity ^0.8.20;
    5
    
                                                    
                                                
    6
    import {SafeCast} from "./SafeCast.sol";
    7
    
                                                    
                                                
    8
    /**
    9
     * @dev Standard signed math utilities missing in the Solidity language.
    10
     */
    11
    ✓ 15
    library SignedMath {
    12
        /**
    13
         * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
    14
         *
    15
         * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
    16
         * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
    17
         * one branch when needed, making this function more expensive.
    18
         */
    19
        function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
    20
            unchecked {
    21
                // branchless ternary works because:
    22
                // b ^ (a ^ b) == a
    23
                // b ^ 0 == b
    24
                return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
    25
            }
    26
        }
    27
    
                                                    
                                                
    28
        /**
    29
         * @dev Returns the largest of two signed numbers.
    30
         */
    31
        function max(int256 a, int256 b) internal pure returns (int256) {
    32
            return ternary(a > b, a, b);
    33
        }
    34
    
                                                    
                                                
    35
        /**
    36
         * @dev Returns the smallest of two signed numbers.
    37
         */
    38
        function min(int256 a, int256 b) internal pure returns (int256) {
    39
            return ternary(a < b, a, b);
    40
        }
    41
    
                                                    
                                                
    42
        /**
    43
         * @dev Returns the average of two signed numbers without overflow.
    44
         * The result is rounded towards zero.
    45
         */
    46
        function average(int256 a, int256 b) internal pure returns (int256) {
    47
            // Formula from the book "Hacker's Delight"
    48
            int256 x = (a & b) + ((a ^ b) >> 1);
    49
            return x + (int256(uint256(x) >> 255) & (a ^ b));
    50
        }
    51
    
                                                    
                                                
    52
        /**
    53
         * @dev Returns the absolute unsigned value of a signed value.
    54
         */
    55
        function abs(int256 n) internal pure returns (uint256) {
    56
            unchecked {
    57
                // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
    58
                // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
    59
                // taking advantage of the most significant (or "sign" bit) in two's complement representation.
    60
                // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
    61
                // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
    62
                int256 mask = n >> 255;
    63
    
                                                    
                                                
    64
                // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
    65
                return uint256((n + mask) ^ mask);
    66
            }
    67
        }
    68
    }
    69
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/Base.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {StdStorage} from "./StdStorage.sol";
    5
    import {Vm, VmSafe} from "./Vm.sol";
    6
    
                                                    
                                                
    7
    abstract contract CommonBase {
    8
        // Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D.
    9
        address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
    10
        // console.sol and console2.sol work by executing a staticcall to this address.
    11
        address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
    12
        // Used when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
    13
        address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    14
        // Default address for tx.origin and msg.sender, 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38.
    15
        address internal constant DEFAULT_SENDER = address(uint160(uint256(keccak256("foundry default caller"))));
    16
        // Address of the test contract, deployed by the DEFAULT_SENDER.
    17
        address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
    18
        // Deterministic deployment address of the Multicall3 contract.
    19
        address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
    20
        // The order of the secp256k1 curve.
    21
        uint256 internal constant SECP256K1_ORDER =
    22
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    23
    
                                                    
                                                
    24
        uint256 internal constant UINT256_MAX =
    25
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    26
    
                                                    
                                                
    27
        Vm internal constant vm = Vm(VM_ADDRESS);
    28
        StdStorage internal stdstore;
    29
    }
    30
    
                                                    
                                                
    31
    abstract contract TestBase is CommonBase {}
    32
    
                                                    
                                                
    33
    abstract contract ScriptBase is CommonBase {
    34
        VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
    35
    }
    36
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/StdAssertions.sol
    Lines covered: 0 / 5 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    pragma experimental ABIEncoderV2;
    4
    
                                                    
                                                
    5
    import {Vm} from "./Vm.sol";
    6
    
                                                    
                                                
    7
    abstract contract StdAssertions {
    8
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    9
    
                                                    
                                                
    10
        event log(string);
    11
        event logs(bytes);
    12
    
                                                    
                                                
    13
        event log_address(address);
    14
        event log_bytes32(bytes32);
    15
        event log_int(int256);
    16
        event log_uint(uint256);
    17
        event log_bytes(bytes);
    18
        event log_string(string);
    19
    
                                                    
                                                
    20
        event log_named_address(string key, address val);
    21
        event log_named_bytes32(string key, bytes32 val);
    22
        event log_named_decimal_int(string key, int256 val, uint256 decimals);
    23
        event log_named_decimal_uint(string key, uint256 val, uint256 decimals);
    24
        event log_named_int(string key, int256 val);
    25
        event log_named_uint(string key, uint256 val);
    26
        event log_named_bytes(string key, bytes val);
    27
        event log_named_string(string key, string val);
    28
    
                                                    
                                                
    29
        event log_array(uint256[] val);
    30
        event log_array(int256[] val);
    31
        event log_array(address[] val);
    32
        event log_named_array(string key, uint256[] val);
    33
        event log_named_array(string key, int256[] val);
    34
        event log_named_array(string key, address[] val);
    35
    
                                                    
                                                
    36
        bool private _failed;
    37
    
                                                    
                                                
    38
        function failed() public view returns (bool) {
    39
            if (_failed) {
    40
                return _failed;
    41
            } else {
    42
                return vm.load(address(vm), bytes32("failed")) != bytes32(0);
    43
            }
    44
        }
    45
    
                                                    
                                                
    46
        function fail() internal virtual {
    47
            vm.store(address(vm), bytes32("failed"), bytes32(uint256(1)));
    48
            _failed = true;
    49
        }
    50
    
                                                    
                                                
    51
        function assertTrue(bool data) internal pure virtual {
    52
            vm.assertTrue(data);
    53
        }
    54
    
                                                    
                                                
    55
        function assertTrue(bool data, string memory err) internal pure virtual {
    56
            vm.assertTrue(data, err);
    57
        }
    58
    
                                                    
                                                
    59
        function assertFalse(bool data) internal pure virtual {
    60
            vm.assertFalse(data);
    61
        }
    62
    
                                                    
                                                
    63
        function assertFalse(bool data, string memory err) internal pure virtual {
    64
            vm.assertFalse(data, err);
    65
        }
    66
    
                                                    
                                                
    67
        function assertEq(bool left, bool right) internal pure virtual {
    68
            vm.assertEq(left, right);
    69
        }
    70
    
                                                    
                                                
    71
        function assertEq(bool left, bool right, string memory err) internal pure virtual {
    72
            vm.assertEq(left, right, err);
    73
        }
    74
    
                                                    
                                                
    75
        function assertEq(uint256 left, uint256 right) internal pure virtual {
    76
            vm.assertEq(left, right);
    77
        }
    78
    
                                                    
                                                
    79
        function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    80
            vm.assertEq(left, right, err);
    81
        }
    82
    
                                                    
                                                
    83
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    84
            vm.assertEqDecimal(left, right, decimals);
    85
        }
    86
    
                                                    
                                                
    87
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    88
            vm.assertEqDecimal(left, right, decimals, err);
    89
        }
    90
    
                                                    
                                                
    91
        function assertEq(int256 left, int256 right) internal pure virtual {
    92
            vm.assertEq(left, right);
    93
        }
    94
    
                                                    
                                                
    95
        function assertEq(int256 left, int256 right, string memory err) internal pure virtual {
    96
            vm.assertEq(left, right, err);
    97
        }
    98
    
                                                    
                                                
    99
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    100
            vm.assertEqDecimal(left, right, decimals);
    101
        }
    102
    
                                                    
                                                
    103
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    104
            vm.assertEqDecimal(left, right, decimals, err);
    105
        }
    106
    
                                                    
                                                
    107
        function assertEq(address left, address right) internal pure virtual {
    108
            vm.assertEq(left, right);
    109
        }
    110
    
                                                    
                                                
    111
        function assertEq(address left, address right, string memory err) internal pure virtual {
    112
            vm.assertEq(left, right, err);
    113
        }
    114
    
                                                    
                                                
    115
        function assertEq(bytes32 left, bytes32 right) internal pure virtual {
    116
            vm.assertEq(left, right);
    117
        }
    118
    
                                                    
                                                
    119
        function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    120
            vm.assertEq(left, right, err);
    121
        }
    122
    
                                                    
                                                
    123
        function assertEq32(bytes32 left, bytes32 right) internal pure virtual {
    124
            assertEq(left, right);
    125
        }
    126
    
                                                    
                                                
    127
        function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    128
            assertEq(left, right, err);
    129
        }
    130
    
                                                    
                                                
    131
        function assertEq(string memory left, string memory right) internal pure virtual {
    132
            vm.assertEq(left, right);
    133
        }
    134
    
                                                    
                                                
    135
        function assertEq(string memory left, string memory right, string memory err) internal pure virtual {
    136
            vm.assertEq(left, right, err);
    137
        }
    138
    
                                                    
                                                
    139
        function assertEq(bytes memory left, bytes memory right) internal pure virtual {
    140
            vm.assertEq(left, right);
    141
        }
    142
    
                                                    
                                                
    143
        function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    144
            vm.assertEq(left, right, err);
    145
        }
    146
    
                                                    
                                                
    147
        function assertEq(bool[] memory left, bool[] memory right) internal pure virtual {
    148
            vm.assertEq(left, right);
    149
        }
    150
    
                                                    
                                                
    151
        function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    152
            vm.assertEq(left, right, err);
    153
        }
    154
    
                                                    
                                                
    155
        function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    156
            vm.assertEq(left, right);
    157
        }
    158
    
                                                    
                                                
    159
        function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    160
            vm.assertEq(left, right, err);
    161
        }
    162
    
                                                    
                                                
    163
        function assertEq(int256[] memory left, int256[] memory right) internal pure virtual {
    164
            vm.assertEq(left, right);
    165
        }
    166
    
                                                    
                                                
    167
        function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    168
            vm.assertEq(left, right, err);
    169
        }
    170
    
                                                    
                                                
    171
        function assertEq(address[] memory left, address[] memory right) internal pure virtual {
    172
            vm.assertEq(left, right);
    173
        }
    174
    
                                                    
                                                
    175
        function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    176
            vm.assertEq(left, right, err);
    177
        }
    178
    
                                                    
                                                
    179
        function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    180
            vm.assertEq(left, right);
    181
        }
    182
    
                                                    
                                                
    183
        function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    184
            vm.assertEq(left, right, err);
    185
        }
    186
    
                                                    
                                                
    187
        function assertEq(string[] memory left, string[] memory right) internal pure virtual {
    188
            vm.assertEq(left, right);
    189
        }
    190
    
                                                    
                                                
    191
        function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    192
            vm.assertEq(left, right, err);
    193
        }
    194
    
                                                    
                                                
    195
        function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    196
            vm.assertEq(left, right);
    197
        }
    198
    
                                                    
                                                
    199
        function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    200
            vm.assertEq(left, right, err);
    201
        }
    202
    
                                                    
                                                
    203
        // Legacy helper
    204
        function assertEqUint(uint256 left, uint256 right) internal pure virtual {
    205
            assertEq(left, right);
    206
        }
    207
    
                                                    
                                                
    208
        function assertNotEq(bool left, bool right) internal pure virtual {
    209
            vm.assertNotEq(left, right);
    210
        }
    211
    
                                                    
                                                
    212
        function assertNotEq(bool left, bool right, string memory err) internal pure virtual {
    213
            vm.assertNotEq(left, right, err);
    214
        }
    215
    
                                                    
                                                
    216
        function assertNotEq(uint256 left, uint256 right) internal pure virtual {
    217
            vm.assertNotEq(left, right);
    218
        }
    219
    
                                                    
                                                
    220
        function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    221
            vm.assertNotEq(left, right, err);
    222
        }
    223
    
                                                    
                                                
    224
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    225
            vm.assertNotEqDecimal(left, right, decimals);
    226
        }
    227
    
                                                    
                                                
    228
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err)
    229
            internal
    230
            pure
    231
            virtual
    232
        {
    233
            vm.assertNotEqDecimal(left, right, decimals, err);
    234
        }
    235
    
                                                    
                                                
    236
        function assertNotEq(int256 left, int256 right) internal pure virtual {
    237
            vm.assertNotEq(left, right);
    238
        }
    239
    
                                                    
                                                
    240
        function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {
    241
            vm.assertNotEq(left, right, err);
    242
        }
    243
    
                                                    
                                                
    244
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    245
            vm.assertNotEqDecimal(left, right, decimals);
    246
        }
    247
    
                                                    
                                                
    248
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    249
            vm.assertNotEqDecimal(left, right, decimals, err);
    250
        }
    251
    
                                                    
                                                
    252
        function assertNotEq(address left, address right) internal pure virtual {
    253
            vm.assertNotEq(left, right);
    254
        }
    255
    
                                                    
                                                
    256
        function assertNotEq(address left, address right, string memory err) internal pure virtual {
    257
            vm.assertNotEq(left, right, err);
    258
        }
    259
    
                                                    
                                                
    260
        function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {
    261
            vm.assertNotEq(left, right);
    262
        }
    263
    
                                                    
                                                
    264
        function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    265
            vm.assertNotEq(left, right, err);
    266
        }
    267
    
                                                    
                                                
    268
        function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {
    269
            assertNotEq(left, right);
    270
        }
    271
    
                                                    
                                                
    272
        function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    273
            assertNotEq(left, right, err);
    274
        }
    275
    
                                                    
                                                
    276
        function assertNotEq(string memory left, string memory right) internal pure virtual {
    277
            vm.assertNotEq(left, right);
    278
        }
    279
    
                                                    
                                                
    280
        function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual {
    281
            vm.assertNotEq(left, right, err);
    282
        }
    283
    
                                                    
                                                
    284
        function assertNotEq(bytes memory left, bytes memory right) internal pure virtual {
    285
            vm.assertNotEq(left, right);
    286
        }
    287
    
                                                    
                                                
    288
        function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    289
            vm.assertNotEq(left, right, err);
    290
        }
    291
    
                                                    
                                                
    292
        function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual {
    293
            vm.assertNotEq(left, right);
    294
        }
    295
    
                                                    
                                                
    296
        function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    297
            vm.assertNotEq(left, right, err);
    298
        }
    299
    
                                                    
                                                
    300
        function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    301
            vm.assertNotEq(left, right);
    302
        }
    303
    
                                                    
                                                
    304
        function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    305
            vm.assertNotEq(left, right, err);
    306
        }
    307
    
                                                    
                                                
    308
        function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual {
    309
            vm.assertNotEq(left, right);
    310
        }
    311
    
                                                    
                                                
    312
        function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    313
            vm.assertNotEq(left, right, err);
    314
        }
    315
    
                                                    
                                                
    316
        function assertNotEq(address[] memory left, address[] memory right) internal pure virtual {
    317
            vm.assertNotEq(left, right);
    318
        }
    319
    
                                                    
                                                
    320
        function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    321
            vm.assertNotEq(left, right, err);
    322
        }
    323
    
                                                    
                                                
    324
        function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    325
            vm.assertNotEq(left, right);
    326
        }
    327
    
                                                    
                                                
    328
        function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    329
            vm.assertNotEq(left, right, err);
    330
        }
    331
    
                                                    
                                                
    332
        function assertNotEq(string[] memory left, string[] memory right) internal pure virtual {
    333
            vm.assertNotEq(left, right);
    334
        }
    335
    
                                                    
                                                
    336
        function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    337
            vm.assertNotEq(left, right, err);
    338
        }
    339
    
                                                    
                                                
    340
        function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    341
            vm.assertNotEq(left, right);
    342
        }
    343
    
                                                    
                                                
    344
        function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    345
            vm.assertNotEq(left, right, err);
    346
        }
    347
    
                                                    
                                                
    348
        function assertLt(uint256 left, uint256 right) internal pure virtual {
    349
            vm.assertLt(left, right);
    350
        }
    351
    
                                                    
                                                
    352
        function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {
    353
            vm.assertLt(left, right, err);
    354
        }
    355
    
                                                    
                                                
    356
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    357
            vm.assertLtDecimal(left, right, decimals);
    358
        }
    359
    
                                                    
                                                
    360
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    361
            vm.assertLtDecimal(left, right, decimals, err);
    362
        }
    363
    
                                                    
                                                
    364
        function assertLt(int256 left, int256 right) internal pure virtual {
    365
            vm.assertLt(left, right);
    366
        }
    367
    
                                                    
                                                
    368
        function assertLt(int256 left, int256 right, string memory err) internal pure virtual {
    369
            vm.assertLt(left, right, err);
    370
        }
    371
    
                                                    
                                                
    372
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    373
            vm.assertLtDecimal(left, right, decimals);
    374
        }
    375
    
                                                    
                                                
    376
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    377
            vm.assertLtDecimal(left, right, decimals, err);
    378
        }
    379
    
                                                    
                                                
    380
        function assertGt(uint256 left, uint256 right) internal pure virtual {
    381
            vm.assertGt(left, right);
    382
        }
    383
    
                                                    
                                                
    384
        function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {
    385
            vm.assertGt(left, right, err);
    386
        }
    387
    
                                                    
                                                
    388
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    389
            vm.assertGtDecimal(left, right, decimals);
    390
        }
    391
    
                                                    
                                                
    392
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    393
            vm.assertGtDecimal(left, right, decimals, err);
    394
        }
    395
    
                                                    
                                                
    396
        function assertGt(int256 left, int256 right) internal pure virtual {
    397
            vm.assertGt(left, right);
    398
        }
    399
    
                                                    
                                                
    400
        function assertGt(int256 left, int256 right, string memory err) internal pure virtual {
    401
            vm.assertGt(left, right, err);
    402
        }
    403
    
                                                    
                                                
    404
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    405
            vm.assertGtDecimal(left, right, decimals);
    406
        }
    407
    
                                                    
                                                
    408
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    409
            vm.assertGtDecimal(left, right, decimals, err);
    410
        }
    411
    
                                                    
                                                
    412
        function assertLe(uint256 left, uint256 right) internal pure virtual {
    413
            vm.assertLe(left, right);
    414
        }
    415
    
                                                    
                                                
    416
        function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {
    417
            vm.assertLe(left, right, err);
    418
        }
    419
    
                                                    
                                                
    420
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    421
            vm.assertLeDecimal(left, right, decimals);
    422
        }
    423
    
                                                    
                                                
    424
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    425
            vm.assertLeDecimal(left, right, decimals, err);
    426
        }
    427
    
                                                    
                                                
    428
        function assertLe(int256 left, int256 right) internal pure virtual {
    429
            vm.assertLe(left, right);
    430
        }
    431
    
                                                    
                                                
    432
        function assertLe(int256 left, int256 right, string memory err) internal pure virtual {
    433
            vm.assertLe(left, right, err);
    434
        }
    435
    
                                                    
                                                
    436
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    437
            vm.assertLeDecimal(left, right, decimals);
    438
        }
    439
    
                                                    
                                                
    440
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    441
            vm.assertLeDecimal(left, right, decimals, err);
    442
        }
    443
    
                                                    
                                                
    444
        function assertGe(uint256 left, uint256 right) internal pure virtual {
    445
            vm.assertGe(left, right);
    446
        }
    447
    
                                                    
                                                
    448
        function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {
    449
            vm.assertGe(left, right, err);
    450
        }
    451
    
                                                    
                                                
    452
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    453
            vm.assertGeDecimal(left, right, decimals);
    454
        }
    455
    
                                                    
                                                
    456
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    457
            vm.assertGeDecimal(left, right, decimals, err);
    458
        }
    459
    
                                                    
                                                
    460
        function assertGe(int256 left, int256 right) internal pure virtual {
    461
            vm.assertGe(left, right);
    462
        }
    463
    
                                                    
                                                
    464
        function assertGe(int256 left, int256 right, string memory err) internal pure virtual {
    465
            vm.assertGe(left, right, err);
    466
        }
    467
    
                                                    
                                                
    468
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    469
            vm.assertGeDecimal(left, right, decimals);
    470
        }
    471
    
                                                    
                                                
    472
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    473
            vm.assertGeDecimal(left, right, decimals, err);
    474
        }
    475
    
                                                    
                                                
    476
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual {
    477
            vm.assertApproxEqAbs(left, right, maxDelta);
    478
        }
    479
    
                                                    
                                                
    480
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err)
    481
            internal
    482
            pure
    483
            virtual
    484
        {
    485
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    486
        }
    487
    
                                                    
                                                
    488
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)
    489
            internal
    490
            pure
    491
            virtual
    492
        {
    493
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    494
        }
    495
    
                                                    
                                                
    496
        function assertApproxEqAbsDecimal(
    497
            uint256 left,
    498
            uint256 right,
    499
            uint256 maxDelta,
    500
            uint256 decimals,
    501
            string memory err
    502
        ) internal pure virtual {
    503
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    504
        }
    505
    
                                                    
                                                
    506
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual {
    507
            vm.assertApproxEqAbs(left, right, maxDelta);
    508
        }
    509
    
                                                    
                                                
    510
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual {
    511
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    512
        }
    513
    
                                                    
                                                
    514
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)
    515
            internal
    516
            pure
    517
            virtual
    518
        {
    519
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    520
        }
    521
    
                                                    
                                                
    522
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)
    523
            internal
    524
            pure
    525
            virtual
    526
        {
    527
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    528
        }
    529
    
                                                    
                                                
    530
        function assertApproxEqRel(
    531
            uint256 left,
    532
            uint256 right,
    533
            uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
    534
        ) internal pure virtual {
    535
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    536
        }
    537
    
                                                    
                                                
    538
        function assertApproxEqRel(
    539
            uint256 left,
    540
            uint256 right,
    541
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    542
            string memory err
    543
        ) internal pure virtual {
    544
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    545
        }
    546
    
                                                    
                                                
    547
        function assertApproxEqRelDecimal(
    548
            uint256 left,
    549
            uint256 right,
    550
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    551
            uint256 decimals
    552
        ) internal pure virtual {
    553
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    554
        }
    555
    
                                                    
                                                
    556
        function assertApproxEqRelDecimal(
    557
            uint256 left,
    558
            uint256 right,
    559
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    560
            uint256 decimals,
    561
            string memory err
    562
        ) internal pure virtual {
    563
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    564
        }
    565
    
                                                    
                                                
    566
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual {
    567
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    568
        }
    569
    
                                                    
                                                
    570
        function assertApproxEqRel(
    571
            int256 left,
    572
            int256 right,
    573
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    574
            string memory err
    575
        ) internal pure virtual {
    576
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    577
        }
    578
    
                                                    
                                                
    579
        function assertApproxEqRelDecimal(
    580
            int256 left,
    581
            int256 right,
    582
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    583
            uint256 decimals
    584
        ) internal pure virtual {
    585
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    586
        }
    587
    
                                                    
                                                
    588
        function assertApproxEqRelDecimal(
    589
            int256 left,
    590
            int256 right,
    591
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    592
            uint256 decimals,
    593
            string memory err
    594
        ) internal pure virtual {
    595
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    596
        }
    597
    
                                                    
                                                
    598
        // Inherited from DSTest, not used but kept for backwards-compatibility
    599
        function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) {
    600
            return keccak256(left) == keccak256(right);
    601
        }
    602
    
                                                    
                                                
    603
        function assertEq0(bytes memory left, bytes memory right) internal pure virtual {
    604
            assertEq(left, right);
    605
        }
    606
    
                                                    
                                                
    607
        function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    608
            assertEq(left, right, err);
    609
        }
    610
    
                                                    
                                                
    611
        function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual {
    612
            assertNotEq(left, right);
    613
        }
    614
    
                                                    
                                                
    615
        function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    616
            assertNotEq(left, right, err);
    617
        }
    618
    
                                                    
                                                
    619
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
    620
            assertEqCall(target, callDataA, target, callDataB, true);
    621
        }
    622
    
                                                    
                                                
    623
        function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
    624
            internal
    625
            virtual
    626
        {
    627
            assertEqCall(targetA, callDataA, targetB, callDataB, true);
    628
        }
    629
    
                                                    
                                                
    630
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
    631
            internal
    632
            virtual
    633
        {
    634
            assertEqCall(target, callDataA, target, callDataB, strictRevertData);
    635
        }
    636
    
                                                    
                                                
    637
        function assertEqCall(
    638
            address targetA,
    639
            bytes memory callDataA,
    640
            address targetB,
    641
            bytes memory callDataB,
    642
            bool strictRevertData
    643
        ) internal virtual {
    644
            (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
    645
            (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
    646
    
                                                    
                                                
    647
            if (successA && successB) {
    648
                assertEq(returnDataA, returnDataB, "Call return data does not match");
    649
            }
    650
    
                                                    
                                                
    651
            if (!successA && !successB && strictRevertData) {
    652
                assertEq(returnDataA, returnDataB, "Call revert data does not match");
    653
            }
    654
    
                                                    
                                                
    655
            if (!successA && successB) {
    656
                emit log("Error: Calls were not equal");
    657
                emit log_named_bytes("  Left call revert data", returnDataA);
    658
                emit log_named_bytes(" Right call return data", returnDataB);
    659
                revert("assertion failed");
    660
            }
    661
    
                                                    
                                                
    662
            if (successA && !successB) {
    663
                emit log("Error: Calls were not equal");
    664
                emit log_named_bytes("  Left call return data", returnDataA);
    665
                emit log_named_bytes(" Right call revert data", returnDataB);
    666
                revert("assertion failed");
    667
            }
    668
        }
    669
    }
    670
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/StdChains.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {VmSafe} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    /**
    7
     * StdChains provides information about EVM compatible chains that can be used in scripts/tests.
    8
     * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
    9
     * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
    10
     * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
    11
     * alias used in this contract, which can be found as the first argument to the
    12
     * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.
    13
     *
    14
     * There are two main ways to use this contract:
    15
     *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
    16
     *      `setChain(string memory chainAlias, Chain memory chain)`
    17
     *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
    18
     *
    19
     * The first time either of those are used, chains are initialized with the default set of RPC URLs.
    20
     * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
    21
     * `defaultRpcUrls`.
    22
     *
    23
     * The `setChain` function is straightforward, and it simply saves off the given chain data.
    24
     *
    25
     * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
    26
     * we want to retrieve the RPC URL for `mainnet`:
    27
     *   - If you have specified data with `setChain`, it will return that.
    28
     *   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
    29
     *     is valid (e.g. a URL is specified, or an environment variable is given and exists).
    30
     *   - If neither of the above conditions is met, the default data is returned.
    31
     *
    32
     * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
    33
     */
    34
    abstract contract StdChains {
    35
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    36
    
                                                    
                                                
    37
        bool private stdChainsInitialized;
    38
    
                                                    
                                                
    39
        struct ChainData {
    40
            string name;
    41
            uint256 chainId;
    42
            string rpcUrl;
    43
        }
    44
    
                                                    
                                                
    45
        struct Chain {
    46
            // The chain name.
    47
            string name;
    48
            // The chain's Chain ID.
    49
            uint256 chainId;
    50
            // The chain's alias. (i.e. what gets specified in `foundry.toml`).
    51
            string chainAlias;
    52
            // A default RPC endpoint for this chain.
    53
            // NOTE: This default RPC URL is included for convenience to facilitate quick tests and
    54
            // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
    55
            // usage as you will be throttled and this is a disservice to others who need this endpoint.
    56
            string rpcUrl;
    57
        }
    58
    
                                                    
                                                
    59
        // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
    60
        mapping(string => Chain) private chains;
    61
        // Maps from the chain's alias to it's default RPC URL.
    62
        mapping(string => string) private defaultRpcUrls;
    63
        // Maps from a chain ID to it's alias.
    64
        mapping(uint256 => string) private idToAlias;
    65
    
                                                    
                                                
    66
        bool private fallbackToDefaultRpcUrls = true;
    67
    
                                                    
                                                
    68
        // The RPC URL will be fetched from config or defaultRpcUrls if possible.
    69
        function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
    70
            require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
    71
    
                                                    
                                                
    72
            initializeStdChains();
    73
            chain = chains[chainAlias];
    74
            require(
    75
                chain.chainId != 0,
    76
                string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
    77
            );
    78
    
                                                    
                                                
    79
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    80
        }
    81
    
                                                    
                                                
    82
        function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
    83
            require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
    84
            initializeStdChains();
    85
            string memory chainAlias = idToAlias[chainId];
    86
    
                                                    
                                                
    87
            chain = chains[chainAlias];
    88
    
                                                    
                                                
    89
            require(
    90
                chain.chainId != 0,
    91
                string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
    92
            );
    93
    
                                                    
                                                
    94
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    95
        }
    96
    
                                                    
                                                
    97
        // set chain info, with priority to argument's rpcUrl field.
    98
        function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
    99
            require(
    100
                bytes(chainAlias).length != 0,
    101
                "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
    102
            );
    103
    
                                                    
                                                
    104
            require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
    105
    
                                                    
                                                
    106
            initializeStdChains();
    107
            string memory foundAlias = idToAlias[chain.chainId];
    108
    
                                                    
                                                
    109
            require(
    110
                bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
    111
                string(
    112
                    abi.encodePacked(
    113
                        "StdChains setChain(string,ChainData): Chain ID ",
    114
                        vm.toString(chain.chainId),
    115
                        " already used by \"",
    116
                        foundAlias,
    117
                        "\"."
    118
                    )
    119
                )
    120
            );
    121
    
                                                    
                                                
    122
            uint256 oldChainId = chains[chainAlias].chainId;
    123
            delete idToAlias[oldChainId];
    124
    
                                                    
                                                
    125
            chains[chainAlias] =
    126
                Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
    127
            idToAlias[chain.chainId] = chainAlias;
    128
        }
    129
    
                                                    
                                                
    130
        // set chain info, with priority to argument's rpcUrl field.
    131
        function setChain(string memory chainAlias, Chain memory chain) internal virtual {
    132
            setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
    133
        }
    134
    
                                                    
                                                
    135
        function _toUpper(string memory str) private pure returns (string memory) {
    136
            bytes memory strb = bytes(str);
    137
            bytes memory copy = new bytes(strb.length);
    138
            for (uint256 i = 0; i < strb.length; i++) {
    139
                bytes1 b = strb[i];
    140
                if (b >= 0x61 && b <= 0x7A) {
    141
                    copy[i] = bytes1(uint8(b) - 32);
    142
                } else {
    143
                    copy[i] = b;
    144
                }
    145
            }
    146
            return string(copy);
    147
        }
    148
    
                                                    
                                                
    149
        // lookup rpcUrl, in descending order of priority:
    150
        // current -> config (foundry.toml) -> environment variable -> default
    151
        function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)
    152
            private
    153
            view
    154
            returns (Chain memory)
    155
        {
    156
            if (bytes(chain.rpcUrl).length == 0) {
    157
                try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
    158
                    chain.rpcUrl = configRpcUrl;
    159
                } catch (bytes memory err) {
    160
                    string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
    161
                    if (fallbackToDefaultRpcUrls) {
    162
                        chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
    163
                    } else {
    164
                        chain.rpcUrl = vm.envString(envName);
    165
                    }
    166
                    // Distinguish 'not found' from 'cannot read'
    167
                    // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
    168
                    bytes memory oldNotFoundError =
    169
                        abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
    170
                    bytes memory newNotFoundError = abi.encodeWithSignature(
    171
                        "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
    172
                    );
    173
                    bytes32 errHash = keccak256(err);
    174
                    if (
    175
                        (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
    176
                            || bytes(chain.rpcUrl).length == 0
    177
                    ) {
    178
                        /// @solidity memory-safe-assembly
    179
                        assembly {
    180
                            revert(add(32, err), mload(err))
    181
                        }
    182
                    }
    183
                }
    184
            }
    185
            return chain;
    186
        }
    187
    
                                                    
                                                
    188
        function setFallbackToDefaultRpcUrls(bool useDefault) internal {
    189
            fallbackToDefaultRpcUrls = useDefault;
    190
        }
    191
    
                                                    
                                                
    192
        function initializeStdChains() private {
    193
            if (stdChainsInitialized) return;
    194
    
                                                    
                                                
    195
            stdChainsInitialized = true;
    196
    
                                                    
                                                
    197
            // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`
    198
            setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
    199
            setChainWithDefaultRpcUrl(
    200
                "mainnet", ChainData("Mainnet", 1, "https://eth-mainnet.alchemyapi.io/v2/pwc5rmJhrdoaSEfimoKEmsvOjKSmPDrP")
    201
            );
    202
            setChainWithDefaultRpcUrl(
    203
                "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
    204
            );
    205
            setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));
    206
            setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
    207
            setChainWithDefaultRpcUrl(
    208
                "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")
    209
            );
    210
            setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
    211
            setChainWithDefaultRpcUrl(
    212
                "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")
    213
            );
    214
            setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
    215
            setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
    216
            setChainWithDefaultRpcUrl(
    217
                "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")
    218
            );
    219
            setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
    220
            setChainWithDefaultRpcUrl(
    221
                "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
    222
            );
    223
            setChainWithDefaultRpcUrl(
    224
                "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
    225
            );
    226
            setChainWithDefaultRpcUrl(
    227
                "bnb_smart_chain_testnet",
    228
                ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
    229
            );
    230
            setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
    231
            setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
    232
            setChainWithDefaultRpcUrl(
    233
                "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
    234
            );
    235
            setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
    236
            setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));
    237
            setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
    238
            setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));
    239
            setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));
    240
            setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));
    241
            setChainWithDefaultRpcUrl(
    242
                "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")
    243
            );
    244
            setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));
    245
            setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com"));
    246
            setChainWithDefaultRpcUrl(
    247
                "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")
    248
            );
    249
            setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));
    250
            setChainWithDefaultRpcUrl(
    251
                "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")
    252
            );
    253
    
                                                    
                                                
    254
            setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org"));
    255
            setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network"));
    256
    
                                                    
                                                
    257
            setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org"));
    258
            setChainWithDefaultRpcUrl(
    259
                "zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy")
    260
            );
    261
    
                                                    
                                                
    262
            setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io"));
    263
            setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io"));
    264
    
                                                    
                                                
    265
            setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org"));
    266
            setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com"));
    267
    
                                                    
                                                
    268
            setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com"));
    269
            setChainWithDefaultRpcUrl(
    270
                "binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com")
    271
            );
    272
    
                                                    
                                                
    273
            setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network"));
    274
            setChainWithDefaultRpcUrl(
    275
                "orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org")
    276
            );
    277
        }
    278
    
                                                    
                                                
    279
        // set chain info, with priority to chainAlias' rpc url in foundry.toml
    280
        function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
    281
            string memory rpcUrl = chain.rpcUrl;
    282
            defaultRpcUrls[chainAlias] = rpcUrl;
    283
            chain.rpcUrl = "";
    284
            setChain(chainAlias, chain);
    285
            chain.rpcUrl = rpcUrl; // restore argument
    286
        }
    287
    }
    288
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/StdCheats.sol
    Lines covered: 0 / 7 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    7
    import {console2} from "./console2.sol";
    8
    import {Vm} from "./Vm.sol";
    9
    
                                                    
                                                
    10
    abstract contract StdCheatsSafe {
    11
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    12
    
                                                    
                                                
    13
        uint256 private constant UINT256_MAX =
    14
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    15
    
                                                    
                                                
    16
        bool private gasMeteringOff;
    17
    
                                                    
                                                
    18
        // Data structures to parse Transaction objects from the broadcast artifact
    19
        // that conform to EIP1559. The Raw structs is what is parsed from the JSON
    20
        // and then converted to the one that is used by the user for better UX.
    21
    
                                                    
                                                
    22
        struct RawTx1559 {
    23
            string[] arguments;
    24
            address contractAddress;
    25
            string contractName;
    26
            // json value name = function
    27
            string functionSig;
    28
            bytes32 hash;
    29
            // json value name = tx
    30
            RawTx1559Detail txDetail;
    31
            // json value name = type
    32
            string opcode;
    33
        }
    34
    
                                                    
                                                
    35
        struct RawTx1559Detail {
    36
            AccessList[] accessList;
    37
            bytes data;
    38
            address from;
    39
            bytes gas;
    40
            bytes nonce;
    41
            address to;
    42
            bytes txType;
    43
            bytes value;
    44
        }
    45
    
                                                    
                                                
    46
        struct Tx1559 {
    47
            string[] arguments;
    48
            address contractAddress;
    49
            string contractName;
    50
            string functionSig;
    51
            bytes32 hash;
    52
            Tx1559Detail txDetail;
    53
            string opcode;
    54
        }
    55
    
                                                    
                                                
    56
        struct Tx1559Detail {
    57
            AccessList[] accessList;
    58
            bytes data;
    59
            address from;
    60
            uint256 gas;
    61
            uint256 nonce;
    62
            address to;
    63
            uint256 txType;
    64
            uint256 value;
    65
        }
    66
    
                                                    
                                                
    67
        // Data structures to parse Transaction objects from the broadcast artifact
    68
        // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON
    69
        // and then converted to the one that is used by the user for better UX.
    70
    
                                                    
                                                
    71
        struct TxLegacy {
    72
            string[] arguments;
    73
            address contractAddress;
    74
            string contractName;
    75
            string functionSig;
    76
            string hash;
    77
            string opcode;
    78
            TxDetailLegacy transaction;
    79
        }
    80
    
                                                    
                                                
    81
        struct TxDetailLegacy {
    82
            AccessList[] accessList;
    83
            uint256 chainId;
    84
            bytes data;
    85
            address from;
    86
            uint256 gas;
    87
            uint256 gasPrice;
    88
            bytes32 hash;
    89
            uint256 nonce;
    90
            bytes1 opcode;
    91
            bytes32 r;
    92
            bytes32 s;
    93
            uint256 txType;
    94
            address to;
    95
            uint8 v;
    96
            uint256 value;
    97
        }
    98
    
                                                    
                                                
    99
        struct AccessList {
    100
            address accessAddress;
    101
            bytes32[] storageKeys;
    102
        }
    103
    
                                                    
                                                
    104
        // Data structures to parse Receipt objects from the broadcast artifact.
    105
        // The Raw structs is what is parsed from the JSON
    106
        // and then converted to the one that is used by the user for better UX.
    107
    
                                                    
                                                
    108
        struct RawReceipt {
    109
            bytes32 blockHash;
    110
            bytes blockNumber;
    111
            address contractAddress;
    112
            bytes cumulativeGasUsed;
    113
            bytes effectiveGasPrice;
    114
            address from;
    115
            bytes gasUsed;
    116
            RawReceiptLog[] logs;
    117
            bytes logsBloom;
    118
            bytes status;
    119
            address to;
    120
            bytes32 transactionHash;
    121
            bytes transactionIndex;
    122
        }
    123
    
                                                    
                                                
    124
        struct Receipt {
    125
            bytes32 blockHash;
    126
            uint256 blockNumber;
    127
            address contractAddress;
    128
            uint256 cumulativeGasUsed;
    129
            uint256 effectiveGasPrice;
    130
            address from;
    131
            uint256 gasUsed;
    132
            ReceiptLog[] logs;
    133
            bytes logsBloom;
    134
            uint256 status;
    135
            address to;
    136
            bytes32 transactionHash;
    137
            uint256 transactionIndex;
    138
        }
    139
    
                                                    
                                                
    140
        // Data structures to parse the entire broadcast artifact, assuming the
    141
        // transactions conform to EIP1559.
    142
    
                                                    
                                                
    143
        struct EIP1559ScriptArtifact {
    144
            string[] libraries;
    145
            string path;
    146
            string[] pending;
    147
            Receipt[] receipts;
    148
            uint256 timestamp;
    149
            Tx1559[] transactions;
    150
            TxReturn[] txReturns;
    151
        }
    152
    
                                                    
                                                
    153
        struct RawEIP1559ScriptArtifact {
    154
            string[] libraries;
    155
            string path;
    156
            string[] pending;
    157
            RawReceipt[] receipts;
    158
            TxReturn[] txReturns;
    159
            uint256 timestamp;
    160
            RawTx1559[] transactions;
    161
        }
    162
    
                                                    
                                                
    163
        struct RawReceiptLog {
    164
            // json value = address
    165
            address logAddress;
    166
            bytes32 blockHash;
    167
            bytes blockNumber;
    168
            bytes data;
    169
            bytes logIndex;
    170
            bool removed;
    171
            bytes32[] topics;
    172
            bytes32 transactionHash;
    173
            bytes transactionIndex;
    174
            bytes transactionLogIndex;
    175
        }
    176
    
                                                    
                                                
    177
        struct ReceiptLog {
    178
            // json value = address
    179
            address logAddress;
    180
            bytes32 blockHash;
    181
            uint256 blockNumber;
    182
            bytes data;
    183
            uint256 logIndex;
    184
            bytes32[] topics;
    185
            uint256 transactionIndex;
    186
            uint256 transactionLogIndex;
    187
            bool removed;
    188
        }
    189
    
                                                    
                                                
    190
        struct TxReturn {
    191
            string internalType;
    192
            string value;
    193
        }
    194
    
                                                    
                                                
    195
        struct Account {
    196
            address addr;
    197
            uint256 key;
    198
        }
    199
    
                                                    
                                                
    200
        enum AddressType {
    201
            Payable,
    202
            NonPayable,
    203
            ZeroAddress,
    204
            Precompile,
    205
            ForgeAddress
    206
        }
    207
    
                                                    
                                                
    208
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    209
        function assumeNotBlacklisted(address token, address addr) internal view virtual {
    210
            // Nothing to check if `token` is not a contract.
    211
            uint256 tokenCodeSize;
    212
            assembly {
    213
                tokenCodeSize := extcodesize(token)
    214
            }
    215
            require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
    216
    
                                                    
                                                
    217
            bool success;
    218
            bytes memory returnData;
    219
    
                                                    
                                                
    220
            // 4-byte selector for `isBlacklisted(address)`, used by USDC.
    221
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
    222
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    223
    
                                                    
                                                
    224
            // 4-byte selector for `isBlackListed(address)`, used by USDT.
    225
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
    226
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    227
        }
    228
    
                                                    
                                                
    229
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    230
        // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for
    231
        // backwards compatibility, since this name was used in the original PR which already has
    232
        // a release. This function can be removed in a future release once we want a breaking change.
    233
        function assumeNoBlacklisted(address token, address addr) internal view virtual {
    234
            assumeNotBlacklisted(token, addr);
    235
        }
    236
    
                                                    
                                                
    237
        function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
    238
            if (addressType == AddressType.Payable) {
    239
                assumeNotPayable(addr);
    240
            } else if (addressType == AddressType.NonPayable) {
    241
                assumePayable(addr);
    242
            } else if (addressType == AddressType.ZeroAddress) {
    243
                assumeNotZeroAddress(addr);
    244
            } else if (addressType == AddressType.Precompile) {
    245
                assumeNotPrecompile(addr);
    246
            } else if (addressType == AddressType.ForgeAddress) {
    247
                assumeNotForgeAddress(addr);
    248
            }
    249
        }
    250
    
                                                    
                                                
    251
        function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
    252
            assumeAddressIsNot(addr, addressType1);
    253
            assumeAddressIsNot(addr, addressType2);
    254
        }
    255
    
                                                    
                                                
    256
        function assumeAddressIsNot(
    257
            address addr,
    258
            AddressType addressType1,
    259
            AddressType addressType2,
    260
            AddressType addressType3
    261
        ) internal virtual {
    262
            assumeAddressIsNot(addr, addressType1);
    263
            assumeAddressIsNot(addr, addressType2);
    264
            assumeAddressIsNot(addr, addressType3);
    265
        }
    266
    
                                                    
                                                
    267
        function assumeAddressIsNot(
    268
            address addr,
    269
            AddressType addressType1,
    270
            AddressType addressType2,
    271
            AddressType addressType3,
    272
            AddressType addressType4
    273
        ) internal virtual {
    274
            assumeAddressIsNot(addr, addressType1);
    275
            assumeAddressIsNot(addr, addressType2);
    276
            assumeAddressIsNot(addr, addressType3);
    277
            assumeAddressIsNot(addr, addressType4);
    278
        }
    279
    
                                                    
                                                
    280
        // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
    281
        // `addr` and checking the `success` return value.
    282
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    283
        // implemented by `addr`, which should be taken into account when this function is used.
    284
        function _isPayable(address addr) private returns (bool) {
    285
            require(
    286
                addr.balance < UINT256_MAX,
    287
                "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
    288
            );
    289
            uint256 origBalanceTest = address(this).balance;
    290
            uint256 origBalanceAddr = address(addr).balance;
    291
    
                                                    
                                                
    292
            vm.deal(address(this), 1);
    293
            (bool success,) = payable(addr).call{value: 1}("");
    294
    
                                                    
                                                
    295
            // reset balances
    296
            vm.deal(address(this), origBalanceTest);
    297
            vm.deal(addr, origBalanceAddr);
    298
    
                                                    
                                                
    299
            return success;
    300
        }
    301
    
                                                    
                                                
    302
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    303
        // implemented by `addr`, which should be taken into account when this function is used. See the
    304
        // `_isPayable` method for more information.
    305
        function assumePayable(address addr) internal virtual {
    306
            vm.assume(_isPayable(addr));
    307
        }
    308
    
                                                    
                                                
    309
        function assumeNotPayable(address addr) internal virtual {
    310
            vm.assume(!_isPayable(addr));
    311
        }
    312
    
                                                    
                                                
    313
        function assumeNotZeroAddress(address addr) internal pure virtual {
    314
            vm.assume(addr != address(0));
    315
        }
    316
    
                                                    
                                                
    317
        function assumeNotPrecompile(address addr) internal pure virtual {
    318
            assumeNotPrecompile(addr, _pureChainId());
    319
        }
    320
    
                                                    
                                                
    321
        function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
    322
            // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
    323
            // address), but the same rationale for excluding them applies so we include those too.
    324
    
                                                    
                                                
    325
            // These are reserved by Ethereum and may be on all EVM-compatible chains.
    326
            vm.assume(addr < address(0x1) || addr > address(0xff));
    327
    
                                                    
                                                
    328
            // forgefmt: disable-start
    329
            if (chainId == 10 || chainId == 420) {
    330
                // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
    331
                vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
    332
            } else if (chainId == 42161 || chainId == 421613) {
    333
                // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
    334
                vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
    335
            } else if (chainId == 43114 || chainId == 43113) {
    336
                // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
    337
                vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
    338
                vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
    339
                vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
    340
            }
    341
            // forgefmt: disable-end
    342
        }
    343
    
                                                    
                                                
    344
        function assumeNotForgeAddress(address addr) internal pure virtual {
    345
            // vm, console, and Create2Deployer addresses
    346
            vm.assume(
    347
                addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
    348
                    && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
    349
            );
    350
        }
    351
    
                                                    
                                                
    352
        function assumeUnusedAddress(address addr) internal view virtual {
    353
            uint256 size;
    354
            assembly {
    355
                size := extcodesize(addr)
    356
            }
    357
            vm.assume(size == 0);
    358
    
                                                    
                                                
    359
            assumeNotPrecompile(addr);
    360
            assumeNotZeroAddress(addr);
    361
            assumeNotForgeAddress(addr);
    362
        }
    363
    
                                                    
                                                
    364
        function readEIP1559ScriptArtifact(string memory path)
    365
            internal
    366
            view
    367
            virtual
    368
            returns (EIP1559ScriptArtifact memory)
    369
        {
    370
            string memory data = vm.readFile(path);
    371
            bytes memory parsedData = vm.parseJson(data);
    372
            RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
    373
            EIP1559ScriptArtifact memory artifact;
    374
            artifact.libraries = rawArtifact.libraries;
    375
            artifact.path = rawArtifact.path;
    376
            artifact.timestamp = rawArtifact.timestamp;
    377
            artifact.pending = rawArtifact.pending;
    378
            artifact.txReturns = rawArtifact.txReturns;
    379
            artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
    380
            artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
    381
            return artifact;
    382
        }
    383
    
                                                    
                                                
    384
        function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
    385
            Tx1559[] memory txs = new Tx1559[](rawTxs.length);
    386
            for (uint256 i; i < rawTxs.length; i++) {
    387
                txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
    388
            }
    389
            return txs;
    390
        }
    391
    
                                                    
                                                
    392
        function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
    393
            Tx1559 memory transaction;
    394
            transaction.arguments = rawTx.arguments;
    395
            transaction.contractName = rawTx.contractName;
    396
            transaction.functionSig = rawTx.functionSig;
    397
            transaction.hash = rawTx.hash;
    398
            transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
    399
            transaction.opcode = rawTx.opcode;
    400
            return transaction;
    401
        }
    402
    
                                                    
                                                
    403
        function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
    404
            internal
    405
            pure
    406
            virtual
    407
            returns (Tx1559Detail memory)
    408
        {
    409
            Tx1559Detail memory txDetail;
    410
            txDetail.data = rawDetail.data;
    411
            txDetail.from = rawDetail.from;
    412
            txDetail.to = rawDetail.to;
    413
            txDetail.nonce = _bytesToUint(rawDetail.nonce);
    414
            txDetail.txType = _bytesToUint(rawDetail.txType);
    415
            txDetail.value = _bytesToUint(rawDetail.value);
    416
            txDetail.gas = _bytesToUint(rawDetail.gas);
    417
            txDetail.accessList = rawDetail.accessList;
    418
            return txDetail;
    419
        }
    420
    
                                                    
                                                
    421
        function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
    422
            string memory deployData = vm.readFile(path);
    423
            bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
    424
            RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
    425
            return rawToConvertedEIPTx1559s(rawTxs);
    426
        }
    427
    
                                                    
                                                
    428
        function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
    429
            string memory deployData = vm.readFile(path);
    430
            string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
    431
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    432
            RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
    433
            return rawToConvertedEIPTx1559(rawTx);
    434
        }
    435
    
                                                    
                                                
    436
        // Analogous to readTransactions, but for receipts.
    437
        function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
    438
            string memory deployData = vm.readFile(path);
    439
            bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
    440
            RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
    441
            return rawToConvertedReceipts(rawReceipts);
    442
        }
    443
    
                                                    
                                                
    444
        function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
    445
            string memory deployData = vm.readFile(path);
    446
            string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
    447
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    448
            RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
    449
            return rawToConvertedReceipt(rawReceipt);
    450
        }
    451
    
                                                    
                                                
    452
        function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
    453
            Receipt[] memory receipts = new Receipt[](rawReceipts.length);
    454
            for (uint256 i; i < rawReceipts.length; i++) {
    455
                receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
    456
            }
    457
            return receipts;
    458
        }
    459
    
                                                    
                                                
    460
        function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
    461
            Receipt memory receipt;
    462
            receipt.blockHash = rawReceipt.blockHash;
    463
            receipt.to = rawReceipt.to;
    464
            receipt.from = rawReceipt.from;
    465
            receipt.contractAddress = rawReceipt.contractAddress;
    466
            receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
    467
            receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
    468
            receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
    469
            receipt.status = _bytesToUint(rawReceipt.status);
    470
            receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
    471
            receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
    472
            receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
    473
            receipt.logsBloom = rawReceipt.logsBloom;
    474
            receipt.transactionHash = rawReceipt.transactionHash;
    475
            return receipt;
    476
        }
    477
    
                                                    
                                                
    478
        function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
    479
            internal
    480
            pure
    481
            virtual
    482
            returns (ReceiptLog[] memory)
    483
        {
    484
            ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
    485
            for (uint256 i; i < rawLogs.length; i++) {
    486
                logs[i].logAddress = rawLogs[i].logAddress;
    487
                logs[i].blockHash = rawLogs[i].blockHash;
    488
                logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
    489
                logs[i].data = rawLogs[i].data;
    490
                logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
    491
                logs[i].topics = rawLogs[i].topics;
    492
                logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
    493
                logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
    494
                logs[i].removed = rawLogs[i].removed;
    495
            }
    496
            return logs;
    497
        }
    498
    
                                                    
                                                
    499
        // Deploy a contract by fetching the contract bytecode from
    500
        // the artifacts directory
    501
        // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`
    502
        function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
    503
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    504
            /// @solidity memory-safe-assembly
    505
            assembly {
    506
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    507
            }
    508
    
                                                    
                                                
    509
            require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
    510
        }
    511
    
                                                    
                                                
    512
        function deployCode(string memory what) internal virtual returns (address addr) {
    513
            bytes memory bytecode = vm.getCode(what);
    514
            /// @solidity memory-safe-assembly
    515
            assembly {
    516
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    517
            }
    518
    
                                                    
                                                
    519
            require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
    520
        }
    521
    
                                                    
                                                
    522
        /// @dev deploy contract with value on construction
    523
        function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
    524
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    525
            /// @solidity memory-safe-assembly
    526
            assembly {
    527
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    528
            }
    529
    
                                                    
                                                
    530
            require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
    531
        }
    532
    
                                                    
                                                
    533
        function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
    534
            bytes memory bytecode = vm.getCode(what);
    535
            /// @solidity memory-safe-assembly
    536
            assembly {
    537
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    538
            }
    539
    
                                                    
                                                
    540
            require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
    541
        }
    542
    
                                                    
                                                
    543
        // creates a labeled address and the corresponding private key
    544
        function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
    545
            privateKey = uint256(keccak256(abi.encodePacked(name)));
    546
            addr = vm.addr(privateKey);
    547
            vm.label(addr, name);
    548
        }
    549
    
                                                    
                                                
    550
        // creates a labeled address
    551
        function makeAddr(string memory name) internal virtual returns (address addr) {
    552
            (addr,) = makeAddrAndKey(name);
    553
        }
    554
    
                                                    
                                                
    555
        // Destroys an account immediately, sending the balance to beneficiary.
    556
        // Destroying means: balance will be zero, code will be empty, and nonce will be 0
    557
        // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce
    558
        // only after tx ends, this will run immediately.
    559
        function destroyAccount(address who, address beneficiary) internal virtual {
    560
            uint256 currBalance = who.balance;
    561
            vm.etch(who, abi.encode());
    562
            vm.deal(who, 0);
    563
            vm.resetNonce(who);
    564
    
                                                    
                                                
    565
            uint256 beneficiaryBalance = beneficiary.balance;
    566
            vm.deal(beneficiary, currBalance + beneficiaryBalance);
    567
        }
    568
    
                                                    
                                                
    569
        // creates a struct containing both a labeled address and the corresponding private key
    570
        function makeAccount(string memory name) internal virtual returns (Account memory account) {
    571
            (account.addr, account.key) = makeAddrAndKey(name);
    572
        }
    573
    
                                                    
                                                
    574
        function deriveRememberKey(string memory mnemonic, uint32 index)
    575
            internal
    576
            virtual
    577
            returns (address who, uint256 privateKey)
    578
        {
    579
            privateKey = vm.deriveKey(mnemonic, index);
    580
            who = vm.rememberKey(privateKey);
    581
        }
    582
    
                                                    
                                                
    583
        function _bytesToUint(bytes memory b) private pure returns (uint256) {
    584
            require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
    585
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    586
        }
    587
    
                                                    
                                                
    588
        function isFork() internal view virtual returns (bool status) {
    589
            try vm.activeFork() {
    590
                status = true;
    591
            } catch (bytes memory) {}
    592
        }
    593
    
                                                    
                                                
    594
        modifier skipWhenForking() {
    595
            if (!isFork()) {
    596
                _;
    597
            }
    598
        }
    599
    
                                                    
                                                
    600
        modifier skipWhenNotForking() {
    601
            if (isFork()) {
    602
                _;
    603
            }
    604
        }
    605
    
                                                    
                                                
    606
        modifier noGasMetering() {
    607
            vm.pauseGasMetering();
    608
            // To prevent turning gas monitoring back on with nested functions that use this modifier,
    609
            // we check if gasMetering started in the off position. If it did, we don't want to turn
    610
            // it back on until we exit the top level function that used the modifier
    611
            //
    612
            // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
    613
            // funcA will have `gasStartedOff` as false, funcB will have it as true,
    614
            // so we only turn metering back on at the end of the funcA
    615
            bool gasStartedOff = gasMeteringOff;
    616
            gasMeteringOff = true;
    617
    
                                                    
                                                
    618
            _;
    619
    
                                                    
                                                
    620
            // if gas metering was on when this modifier was called, turn it back on at the end
    621
            if (!gasStartedOff) {
    622
                gasMeteringOff = false;
    623
                vm.resumeGasMetering();
    624
            }
    625
        }
    626
    
                                                    
                                                
    627
        // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
    628
        // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
    629
        // can't simply access the chain ID in a normal view or pure function because the solc View Pure
    630
        // Checker changed `chainid` from pure to view in 0.8.0.
    631
        function _viewChainId() private view returns (uint256 chainId) {
    632
            // Assembly required since `block.chainid` was introduced in 0.8.0.
    633
            assembly {
    634
                chainId := chainid()
    635
            }
    636
    
                                                    
                                                
    637
            address(this); // Silence warnings in older Solc versions.
    638
        }
    639
    
                                                    
                                                
    640
        function _pureChainId() private pure returns (uint256 chainId) {
    641
            function() internal view returns (uint256) fnIn = _viewChainId;
    642
            function() internal pure returns (uint256) pureChainId;
    643
            assembly {
    644
                pureChainId := fnIn
    645
            }
    646
            chainId = pureChainId();
    647
        }
    648
    }
    649
    
                                                    
                                                
    650
    // Wrappers around cheatcodes to avoid footguns
    651
    abstract contract StdCheats is StdCheatsSafe {
    652
        using stdStorage for StdStorage;
    653
    
                                                    
                                                
    654
        StdStorage private stdstore;
    655
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    656
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    657
    
                                                    
                                                
    658
        // Skip forward or rewind time by the specified number of seconds
    659
        function skip(uint256 time) internal virtual {
    660
            vm.warp(vm.getBlockTimestamp() + time);
    661
        }
    662
    
                                                    
                                                
    663
        function rewind(uint256 time) internal virtual {
    664
            vm.warp(vm.getBlockTimestamp() - time);
    665
        }
    666
    
                                                    
                                                
    667
        // Setup a prank from an address that has some ether
    668
        function hoax(address msgSender) internal virtual {
    669
            vm.deal(msgSender, 1 << 128);
    670
            vm.prank(msgSender);
    671
        }
    672
    
                                                    
                                                
    673
        function hoax(address msgSender, uint256 give) internal virtual {
    674
            vm.deal(msgSender, give);
    675
            vm.prank(msgSender);
    676
        }
    677
    
                                                    
                                                
    678
        function hoax(address msgSender, address origin) internal virtual {
    679
            vm.deal(msgSender, 1 << 128);
    680
            vm.prank(msgSender, origin);
    681
        }
    682
    
                                                    
                                                
    683
        function hoax(address msgSender, address origin, uint256 give) internal virtual {
    684
            vm.deal(msgSender, give);
    685
            vm.prank(msgSender, origin);
    686
        }
    687
    
                                                    
                                                
    688
        // Start perpetual prank from an address that has some ether
    689
        function startHoax(address msgSender) internal virtual {
    690
            vm.deal(msgSender, 1 << 128);
    691
            vm.startPrank(msgSender);
    692
        }
    693
    
                                                    
                                                
    694
        function startHoax(address msgSender, uint256 give) internal virtual {
    695
            vm.deal(msgSender, give);
    696
            vm.startPrank(msgSender);
    697
        }
    698
    
                                                    
                                                
    699
        // Start perpetual prank from an address that has some ether
    700
        // tx.origin is set to the origin parameter
    701
        function startHoax(address msgSender, address origin) internal virtual {
    702
            vm.deal(msgSender, 1 << 128);
    703
            vm.startPrank(msgSender, origin);
    704
        }
    705
    
                                                    
                                                
    706
        function startHoax(address msgSender, address origin, uint256 give) internal virtual {
    707
            vm.deal(msgSender, give);
    708
            vm.startPrank(msgSender, origin);
    709
        }
    710
    
                                                    
                                                
    711
        function changePrank(address msgSender) internal virtual {
    712
            console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
    713
            vm.stopPrank();
    714
            vm.startPrank(msgSender);
    715
        }
    716
    
                                                    
                                                
    717
        function changePrank(address msgSender, address txOrigin) internal virtual {
    718
            vm.stopPrank();
    719
            vm.startPrank(msgSender, txOrigin);
    720
        }
    721
    
                                                    
                                                
    722
        // The same as Vm's `deal`
    723
        // Use the alternative signature for ERC20 tokens
    724
        function deal(address to, uint256 give) internal virtual {
    725
            vm.deal(to, give);
    726
        }
    727
    
                                                    
                                                
    728
        // Set the balance of an account for any ERC20 token
    729
        // Use the alternative signature to update `totalSupply`
    730
        function deal(address token, address to, uint256 give) internal virtual {
    731
            deal(token, to, give, false);
    732
        }
    733
    
                                                    
                                                
    734
        // Set the balance of an account for any ERC1155 token
    735
        // Use the alternative signature to update `totalSupply`
    736
        function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
    737
            dealERC1155(token, to, id, give, false);
    738
        }
    739
    
                                                    
                                                
    740
        function deal(address token, address to, uint256 give, bool adjust) internal virtual {
    741
            // get current balance
    742
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    743
            uint256 prevBal = abi.decode(balData, (uint256));
    744
    
                                                    
                                                
    745
            // update balance
    746
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
    747
    
                                                    
                                                
    748
            // update total supply
    749
            if (adjust) {
    750
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
    751
                uint256 totSup = abi.decode(totSupData, (uint256));
    752
                if (give < prevBal) {
    753
                    totSup -= (prevBal - give);
    754
                } else {
    755
                    totSup += (give - prevBal);
    756
                }
    757
                stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
    758
            }
    759
        }
    760
    
                                                    
                                                
    761
        function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
    762
            // get current balance
    763
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
    764
            uint256 prevBal = abi.decode(balData, (uint256));
    765
    
                                                    
                                                
    766
            // update balance
    767
            stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
    768
    
                                                    
                                                
    769
            // update total supply
    770
            if (adjust) {
    771
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
    772
                require(
    773
                    totSupData.length != 0,
    774
                    "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply."
    775
                );
    776
                uint256 totSup = abi.decode(totSupData, (uint256));
    777
                if (give < prevBal) {
    778
                    totSup -= (prevBal - give);
    779
                } else {
    780
                    totSup += (give - prevBal);
    781
                }
    782
                stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
    783
            }
    784
        }
    785
    
                                                    
                                                
    786
        function dealERC721(address token, address to, uint256 id) internal virtual {
    787
            // check if token id is already minted and the actual owner.
    788
            (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
    789
            require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted.");
    790
    
                                                    
                                                
    791
            // get owner current balance
    792
            (, bytes memory fromBalData) =
    793
                token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
    794
            uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
    795
    
                                                    
                                                
    796
            // get new user current balance
    797
            (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    798
            uint256 toPrevBal = abi.decode(toBalData, (uint256));
    799
    
                                                    
                                                
    800
            // update balances
    801
            stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
    802
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
    803
    
                                                    
                                                
    804
            // update owner
    805
            stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
    806
        }
    807
    
                                                    
                                                
    808
        function deployCodeTo(string memory what, address where) internal virtual {
    809
            deployCodeTo(what, "", 0, where);
    810
        }
    811
    
                                                    
                                                
    812
        function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
    813
            deployCodeTo(what, args, 0, where);
    814
        }
    815
    
                                                    
                                                
    816
        function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
    817
            bytes memory creationCode = vm.getCode(what);
    818
            vm.etch(where, abi.encodePacked(creationCode, args));
    819
            (bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
    820
            require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
    821
            vm.etch(where, runtimeBytecode);
    822
        }
    823
    
                                                    
                                                
    824
        // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
    825
        function console2_log_StdCheats(string memory p0) private view {
    826
            (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
    827
            status;
    828
        }
    829
    }
    830
    
                                                    
                                                
    10.0% lib/openzeppelin-contracts/lib/forge-std/src/StdError.sol
    Lines covered: 1 / 10 (10.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
    3
    pragma solidity >=0.6.2 <0.9.0;
    4
    
                                                    
                                                
    5
    ✓ 1
    library stdError {
    6
        bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
    7
        bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
    8
        bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
    9
        bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
    10
        bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
    11
        bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
    12
        bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
    13
        bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
    14
        bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
    15
    }
    16
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/StdInvariant.sol
    Lines covered: 0 / 20 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    abstract contract StdInvariant {
    7
        struct FuzzSelector {
    8
            address addr;
    9
            bytes4[] selectors;
    10
        }
    11
    
                                                    
                                                
    12
        struct FuzzArtifactSelector {
    13
            string artifact;
    14
            bytes4[] selectors;
    15
        }
    16
    
                                                    
                                                
    17
        struct FuzzInterface {
    18
            address addr;
    19
            string[] artifacts;
    20
        }
    21
    
                                                    
                                                
    22
        address[] private _excludedContracts;
    23
        address[] private _excludedSenders;
    24
        address[] private _targetedContracts;
    25
        address[] private _targetedSenders;
    26
    
                                                    
                                                
    27
        string[] private _excludedArtifacts;
    28
        string[] private _targetedArtifacts;
    29
    
                                                    
                                                
    30
        FuzzArtifactSelector[] private _targetedArtifactSelectors;
    31
    
                                                    
                                                
    32
        FuzzSelector[] private _excludedSelectors;
    33
        FuzzSelector[] private _targetedSelectors;
    34
    
                                                    
                                                
    35
        FuzzInterface[] private _targetedInterfaces;
    36
    
                                                    
                                                
    37
        // Functions for users:
    38
        // These are intended to be called in tests.
    39
    
                                                    
                                                
    40
        function excludeContract(address newExcludedContract_) internal {
    41
            _excludedContracts.push(newExcludedContract_);
    42
        }
    43
    
                                                    
                                                
    44
        function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
    45
            _excludedSelectors.push(newExcludedSelector_);
    46
        }
    47
    
                                                    
                                                
    48
        function excludeSender(address newExcludedSender_) internal {
    49
            _excludedSenders.push(newExcludedSender_);
    50
        }
    51
    
                                                    
                                                
    52
        function excludeArtifact(string memory newExcludedArtifact_) internal {
    53
            _excludedArtifacts.push(newExcludedArtifact_);
    54
        }
    55
    
                                                    
                                                
    56
        function targetArtifact(string memory newTargetedArtifact_) internal {
    57
            _targetedArtifacts.push(newTargetedArtifact_);
    58
        }
    59
    
                                                    
                                                
    60
        function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
    61
            _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
    62
        }
    63
    
                                                    
                                                
    64
        function targetContract(address newTargetedContract_) internal {
    65
            _targetedContracts.push(newTargetedContract_);
    66
        }
    67
    
                                                    
                                                
    68
        function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
    69
            _targetedSelectors.push(newTargetedSelector_);
    70
        }
    71
    
                                                    
                                                
    72
        function targetSender(address newTargetedSender_) internal {
    73
            _targetedSenders.push(newTargetedSender_);
    74
        }
    75
    
                                                    
                                                
    76
        function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
    77
            _targetedInterfaces.push(newTargetedInterface_);
    78
        }
    79
    
                                                    
                                                
    80
        // Functions for forge:
    81
        // These are called by forge to run invariant tests and don't need to be called in tests.
    82
    
                                                    
                                                
    83
        function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
    84
            excludedArtifacts_ = _excludedArtifacts;
    85
        }
    86
    
                                                    
                                                
    87
        function excludeContracts() public view returns (address[] memory excludedContracts_) {
    88
            excludedContracts_ = _excludedContracts;
    89
        }
    90
    
                                                    
                                                
    91
        function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
    92
            excludedSelectors_ = _excludedSelectors;
    93
        }
    94
    
                                                    
                                                
    95
        function excludeSenders() public view returns (address[] memory excludedSenders_) {
    96
            excludedSenders_ = _excludedSenders;
    97
        }
    98
    
                                                    
                                                
    99
        function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
    100
            targetedArtifacts_ = _targetedArtifacts;
    101
        }
    102
    
                                                    
                                                
    103
        function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
    104
            targetedArtifactSelectors_ = _targetedArtifactSelectors;
    105
        }
    106
    
                                                    
                                                
    107
        function targetContracts() public view returns (address[] memory targetedContracts_) {
    108
            targetedContracts_ = _targetedContracts;
    109
        }
    110
    
                                                    
                                                
    111
        function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
    112
            targetedSelectors_ = _targetedSelectors;
    113
        }
    114
    
                                                    
                                                
    115
        function targetSenders() public view returns (address[] memory targetedSenders_) {
    116
            targetedSenders_ = _targetedSenders;
    117
        }
    118
    
                                                    
                                                
    119
        function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
    120
            targetedInterfaces_ = _targetedInterfaces;
    121
        }
    122
    }
    123
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/StdJson.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {VmSafe} from "./Vm.sol";
    7
    
                                                    
                                                
    8
    // Helpers for parsing and writing JSON files
    9
    // To parse:
    10
    // ```
    11
    // using stdJson for string;
    12
    // string memory json = vm.readFile("<some_path>");
    13
    // json.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdJson for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    
                                                    
                                                
    25
    ✓ 15
    library stdJson {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    
                                                    
                                                
    28
        function keyExists(string memory json, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsJson(json, key);
    30
        }
    31
    
                                                    
                                                
    32
        function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseJson(json, key);
    34
        }
    35
    
                                                    
                                                
    36
        function readUint(string memory json, string memory key) internal pure returns (uint256) {
    37
            return vm.parseJsonUint(json, key);
    38
        }
    39
    
                                                    
                                                
    40
        function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseJsonUintArray(json, key);
    42
        }
    43
    
                                                    
                                                
    44
        function readInt(string memory json, string memory key) internal pure returns (int256) {
    45
            return vm.parseJsonInt(json, key);
    46
        }
    47
    
                                                    
                                                
    48
        function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseJsonIntArray(json, key);
    50
        }
    51
    
                                                    
                                                
    52
        function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseJsonBytes32(json, key);
    54
        }
    55
    
                                                    
                                                
    56
        function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseJsonBytes32Array(json, key);
    58
        }
    59
    
                                                    
                                                
    60
        function readString(string memory json, string memory key) internal pure returns (string memory) {
    61
            return vm.parseJsonString(json, key);
    62
        }
    63
    
                                                    
                                                
    64
        function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseJsonStringArray(json, key);
    66
        }
    67
    
                                                    
                                                
    68
        function readAddress(string memory json, string memory key) internal pure returns (address) {
    69
            return vm.parseJsonAddress(json, key);
    70
        }
    71
    
                                                    
                                                
    72
        function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseJsonAddressArray(json, key);
    74
        }
    75
    
                                                    
                                                
    76
        function readBool(string memory json, string memory key) internal pure returns (bool) {
    77
            return vm.parseJsonBool(json, key);
    78
        }
    79
    
                                                    
                                                
    80
        function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseJsonBoolArray(json, key);
    82
        }
    83
    
                                                    
                                                
    84
        function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseJsonBytes(json, key);
    86
        }
    87
    
                                                    
                                                
    88
        function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseJsonBytesArray(json, key);
    90
        }
    91
    
                                                    
                                                
    92
        function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(json, key) ? readUint(json, key) : defaultValue;
    94
        }
    95
    
                                                    
                                                
    96
        function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
    102
        }
    103
    
                                                    
                                                
    104
        function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(json, key) ? readInt(json, key) : defaultValue;
    106
        }
    107
    
                                                    
                                                
    108
        function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
    114
        }
    115
    
                                                    
                                                
    116
        function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
    122
        }
    123
    
                                                    
                                                
    124
        function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
    130
        }
    131
    
                                                    
                                                
    132
        function readStringOr(string memory json, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(json, key) ? readString(json, key) : defaultValue;
    138
        }
    139
    
                                                    
                                                
    140
        function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
    146
        }
    147
    
                                                    
                                                
    148
        function readAddressOr(string memory json, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(json, key) ? readAddress(json, key) : defaultValue;
    154
        }
    155
    
                                                    
                                                
    156
        function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
    162
        }
    163
    
                                                    
                                                
    164
        function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(json, key) ? readBool(json, key) : defaultValue;
    166
        }
    167
    
                                                    
                                                
    168
        function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
    174
        }
    175
    
                                                    
                                                
    176
        function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(json, key) ? readBytes(json, key) : defaultValue;
    182
        }
    183
    
                                                    
                                                
    184
        function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
    190
        }
    191
    
                                                    
                                                
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    
                                                    
                                                
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    
                                                    
                                                
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value)
    201
            internal
    202
            returns (string memory)
    203
        {
    204
            return vm.serializeBool(jsonKey, key, value);
    205
        }
    206
    
                                                    
                                                
    207
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    208
            return vm.serializeUint(jsonKey, key, value);
    209
        }
    210
    
                                                    
                                                
    211
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    212
            internal
    213
            returns (string memory)
    214
        {
    215
            return vm.serializeUint(jsonKey, key, value);
    216
        }
    217
    
                                                    
                                                
    218
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    219
            return vm.serializeInt(jsonKey, key, value);
    220
        }
    221
    
                                                    
                                                
    222
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    223
            internal
    224
            returns (string memory)
    225
        {
    226
            return vm.serializeInt(jsonKey, key, value);
    227
        }
    228
    
                                                    
                                                
    229
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    230
            return vm.serializeAddress(jsonKey, key, value);
    231
        }
    232
    
                                                    
                                                
    233
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    234
            internal
    235
            returns (string memory)
    236
        {
    237
            return vm.serializeAddress(jsonKey, key, value);
    238
        }
    239
    
                                                    
                                                
    240
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    241
            return vm.serializeBytes32(jsonKey, key, value);
    242
        }
    243
    
                                                    
                                                
    244
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    245
            internal
    246
            returns (string memory)
    247
        {
    248
            return vm.serializeBytes32(jsonKey, key, value);
    249
        }
    250
    
                                                    
                                                
    251
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    252
            return vm.serializeBytes(jsonKey, key, value);
    253
        }
    254
    
                                                    
                                                
    255
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    256
            internal
    257
            returns (string memory)
    258
        {
    259
            return vm.serializeBytes(jsonKey, key, value);
    260
        }
    261
    
                                                    
                                                
    262
        function serialize(string memory jsonKey, string memory key, string memory value)
    263
            internal
    264
            returns (string memory)
    265
        {
    266
            return vm.serializeString(jsonKey, key, value);
    267
        }
    268
    
                                                    
                                                
    269
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    270
            internal
    271
            returns (string memory)
    272
        {
    273
            return vm.serializeString(jsonKey, key, value);
    274
        }
    275
    
                                                    
                                                
    276
        function write(string memory jsonKey, string memory path) internal {
    277
            vm.writeJson(jsonKey, path);
    278
        }
    279
    
                                                    
                                                
    280
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    281
            vm.writeJson(jsonKey, path, valueKey);
    282
        }
    283
    }
    284
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/StdMath.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    ✓ 15
    library stdMath {
    5
        int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
    6
    
                                                    
                                                
    7
        function abs(int256 a) internal pure returns (uint256) {
    8
            // Required or it will fail when `a = type(int256).min`
    9
            if (a == INT256_MIN) {
    10
                return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
    11
            }
    12
    
                                                    
                                                
    13
            return uint256(a > 0 ? a : -a);
    14
        }
    15
    
                                                    
                                                
    16
        function delta(uint256 a, uint256 b) internal pure returns (uint256) {
    17
            return a > b ? a - b : b - a;
    18
        }
    19
    
                                                    
                                                
    20
        function delta(int256 a, int256 b) internal pure returns (uint256) {
    21
            // a and b are of the same sign
    22
            // this works thanks to two's complement, the left-most bit is the sign bit
    23
            if ((a ^ b) > -1) {
    24
                return delta(abs(a), abs(b));
    25
            }
    26
    
                                                    
                                                
    27
            // a and b are of opposite signs
    28
            return abs(a) + abs(b);
    29
        }
    30
    
                                                    
                                                
    31
        function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
    32
            uint256 absDelta = delta(a, b);
    33
    
                                                    
                                                
    34
            return absDelta * 1e18 / b;
    35
        }
    36
    
                                                    
                                                
    37
        function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
    38
            uint256 absDelta = delta(a, b);
    39
            uint256 absB = abs(b);
    40
    
                                                    
                                                
    41
            return absDelta * 1e18 / absB;
    42
        }
    43
    }
    44
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/StdStorage.sol
    Lines covered: 2 / 2 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    import {Vm} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    struct FindData {
    7
        uint256 slot;
    8
        uint256 offsetLeft;
    9
        uint256 offsetRight;
    10
        bool found;
    11
    }
    12
    
                                                    
                                                
    13
    struct StdStorage {
    14
        mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
    15
        bytes32[] _keys;
    16
        bytes4 _sig;
    17
        uint256 _depth;
    18
        address _target;
    19
        bytes32 _set;
    20
        bool _enable_packed_slots;
    21
        bytes _calldata;
    22
    }
    23
    
                                                    
                                                
    24
    ✓ 15
    library stdStorageSafe {
    25
        event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
    26
        event WARNING_UninitedSlot(address who, uint256 slot);
    27
    
                                                    
                                                
    28
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    29
        uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
    30
    
                                                    
                                                
    31
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    32
            return bytes4(keccak256(bytes(sigStr)));
    33
        }
    34
    
                                                    
                                                
    35
        function getCallParams(StdStorage storage self) internal view returns (bytes memory) {
    36
            if (self._calldata.length == 0) {
    37
                return flatten(self._keys);
    38
            } else {
    39
                return self._calldata;
    40
            }
    41
        }
    42
    
                                                    
                                                
    43
        // Calls target contract with configured parameters
    44
        function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {
    45
            bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));
    46
            (bool success, bytes memory rdat) = self._target.staticcall(cald);
    47
            bytes32 result = bytesToBytes32(rdat, 32 * self._depth);
    48
    
                                                    
                                                
    49
            return (success, result);
    50
        }
    51
    
                                                    
                                                
    52
        // Tries mutating slot value to determine if the targeted value is stored in it.
    53
        // If current value is 0, then we are setting slot value to type(uint256).max
    54
        // Otherwise, we set it to 0. That way, return value should always be affected.
    55
        function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {
    56
            bytes32 prevSlotValue = vm.load(self._target, slot);
    57
            (bool success, bytes32 prevReturnValue) = callTarget(self);
    58
    
                                                    
                                                
    59
            bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);
    60
            vm.store(self._target, slot, testVal);
    61
    
                                                    
                                                
    62
            (, bytes32 newReturnValue) = callTarget(self);
    63
    
                                                    
                                                
    64
            vm.store(self._target, slot, prevSlotValue);
    65
    
                                                    
                                                
    66
            return (success && (prevReturnValue != newReturnValue));
    67
        }
    68
    
                                                    
                                                
    69
        // Tries setting one of the bits in slot to 1 until return value changes.
    70
        // Index of resulted bit is an offset packed slot has from left/right side
    71
        function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {
    72
            for (uint256 offset = 0; offset < 256; offset++) {
    73
                uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);
    74
                vm.store(self._target, slot, bytes32(valueToPut));
    75
    
                                                    
                                                
    76
                (bool success, bytes32 data) = callTarget(self);
    77
    
                                                    
                                                
    78
                if (success && (uint256(data) > 0)) {
    79
                    return (true, offset);
    80
                }
    81
            }
    82
            return (false, 0);
    83
        }
    84
    
                                                    
                                                
    85
        function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {
    86
            bytes32 prevSlotValue = vm.load(self._target, slot);
    87
    
                                                    
                                                
    88
            (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);
    89
            (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);
    90
    
                                                    
                                                
    91
            // `findOffset` may mutate slot value, so we are setting it to initial value
    92
            vm.store(self._target, slot, prevSlotValue);
    93
            return (foundLeft && foundRight, offsetLeft, offsetRight);
    94
        }
    95
    
                                                    
                                                
    96
        function find(StdStorage storage self) internal returns (FindData storage) {
    97
            return find(self, true);
    98
        }
    99
    
                                                    
                                                
    100
        /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
    101
        // slot complexity:
    102
        //  if flat, will be bytes32(uint256(uint));
    103
        //  if map, will be keccak256(abi.encode(key, uint(slot)));
    104
        //  if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
    105
        //  if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
    106
        function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {
    107
            address who = self._target;
    108
            bytes4 fsig = self._sig;
    109
            uint256 field_depth = self._depth;
    110
            bytes memory params = getCallParams(self);
    111
    
                                                    
                                                
    112
            // calldata to test against
    113
            if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    114
                if (_clear) {
    115
                    clear(self);
    116
                }
    117
                return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    118
            }
    119
            vm.record();
    120
            (, bytes32 callResult) = callTarget(self);
    121
            (bytes32[] memory reads,) = vm.accesses(address(who));
    122
    
                                                    
                                                
    123
            if (reads.length == 0) {
    124
                revert("stdStorage find(StdStorage): No storage use detected for target.");
    125
            } else {
    126
                for (uint256 i = reads.length; --i >= 0;) {
    127
                    bytes32 prev = vm.load(who, reads[i]);
    128
                    if (prev == bytes32(0)) {
    129
                        emit WARNING_UninitedSlot(who, uint256(reads[i]));
    130
                    }
    131
    
                                                    
                                                
    132
                    if (!checkSlotMutatesCall(self, reads[i])) {
    133
                        continue;
    134
                    }
    135
    
                                                    
                                                
    136
                    (uint256 offsetLeft, uint256 offsetRight) = (0, 0);
    137
    
                                                    
                                                
    138
                    if (self._enable_packed_slots) {
    139
                        bool found;
    140
                        (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);
    141
                        if (!found) {
    142
                            continue;
    143
                        }
    144
                    }
    145
    
                                                    
                                                
    146
                    // Check that value between found offsets is equal to the current call result
    147
                    uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;
    148
    
                                                    
                                                
    149
                    if (uint256(callResult) != curVal) {
    150
                        continue;
    151
                    }
    152
    
                                                    
                                                
    153
                    emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));
    154
                    self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =
    155
                        FindData(uint256(reads[i]), offsetLeft, offsetRight, true);
    156
                    break;
    157
                }
    158
            }
    159
    
                                                    
                                                
    160
            require(
    161
                self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,
    162
                "stdStorage find(StdStorage): Slot(s) not found."
    163
            );
    164
    
                                                    
                                                
    165
            if (_clear) {
    166
                clear(self);
    167
            }
    168
            return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    169
        }
    170
    
                                                    
                                                
    171
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    172
            self._target = _target;
    173
            return self;
    174
        }
    175
    
                                                    
                                                
    176
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    177
            self._sig = _sig;
    178
            return self;
    179
        }
    180
    
                                                    
                                                
    181
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    182
            self._sig = sigs(_sig);
    183
            return self;
    184
        }
    185
    
                                                    
                                                
    186
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    187
            self._calldata = _calldata;
    188
            return self;
    189
        }
    190
    
                                                    
                                                
    191
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    192
            self._keys.push(bytes32(uint256(uint160(who))));
    193
            return self;
    194
        }
    195
    
                                                    
                                                
    196
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    197
            self._keys.push(bytes32(amt));
    198
            return self;
    199
        }
    200
    
                                                    
                                                
    201
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    202
            self._keys.push(key);
    203
            return self;
    204
        }
    205
    
                                                    
                                                
    206
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    207
            self._enable_packed_slots = true;
    208
            return self;
    209
        }
    210
    
                                                    
                                                
    211
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    212
            self._depth = _depth;
    213
            return self;
    214
        }
    215
    
                                                    
                                                
    216
        function read(StdStorage storage self) private returns (bytes memory) {
    217
            FindData storage data = find(self, false);
    218
            uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);
    219
            uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;
    220
            clear(self);
    221
            return abi.encode(value);
    222
        }
    223
    
                                                    
                                                
    224
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    225
            return abi.decode(read(self), (bytes32));
    226
        }
    227
    
                                                    
                                                
    228
        function read_bool(StdStorage storage self) internal returns (bool) {
    229
            int256 v = read_int(self);
    230
            if (v == 0) return false;
    231
            if (v == 1) return true;
    232
            revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
    233
        }
    234
    
                                                    
                                                
    235
        function read_address(StdStorage storage self) internal returns (address) {
    236
            return abi.decode(read(self), (address));
    237
        }
    238
    
                                                    
                                                
    239
        function read_uint(StdStorage storage self) internal returns (uint256) {
    240
            return abi.decode(read(self), (uint256));
    241
        }
    242
    
                                                    
                                                
    243
        function read_int(StdStorage storage self) internal returns (int256) {
    244
            return abi.decode(read(self), (int256));
    245
        }
    246
    
                                                    
                                                
    247
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    248
            address who = self._target;
    249
            uint256 field_depth = self._depth;
    250
            vm.startMappingRecording();
    251
            uint256 child = find(self, true).slot - field_depth;
    252
            (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    253
            if (!found) {
    254
                revert(
    255
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    256
                );
    257
            }
    258
            return (uint256(parent_slot), key);
    259
        }
    260
    
                                                    
                                                
    261
        function root(StdStorage storage self) internal returns (uint256) {
    262
            address who = self._target;
    263
            uint256 field_depth = self._depth;
    264
            vm.startMappingRecording();
    265
            uint256 child = find(self, true).slot - field_depth;
    266
            bool found;
    267
            bytes32 root_slot;
    268
            bytes32 parent_slot;
    269
            (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    270
            if (!found) {
    271
                revert(
    272
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    273
                );
    274
            }
    275
            while (found) {
    276
                root_slot = parent_slot;
    277
                (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
    278
            }
    279
            return uint256(root_slot);
    280
        }
    281
    
                                                    
                                                
    282
        function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
    283
            bytes32 out;
    284
    
                                                    
                                                
    285
            uint256 max = b.length > 32 ? 32 : b.length;
    286
            for (uint256 i = 0; i < max; i++) {
    287
                out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
    288
            }
    289
            return out;
    290
        }
    291
    
                                                    
                                                
    292
        function flatten(bytes32[] memory b) private pure returns (bytes memory) {
    293
            bytes memory result = new bytes(b.length * 32);
    294
            for (uint256 i = 0; i < b.length; i++) {
    295
                bytes32 k = b[i];
    296
                /// @solidity memory-safe-assembly
    297
                assembly {
    298
                    mstore(add(result, add(32, mul(32, i))), k)
    299
                }
    300
            }
    301
    
                                                    
                                                
    302
            return result;
    303
        }
    304
    
                                                    
                                                
    305
        function clear(StdStorage storage self) internal {
    306
            delete self._target;
    307
            delete self._sig;
    308
            delete self._keys;
    309
            delete self._depth;
    310
            delete self._enable_packed_slots;
    311
            delete self._calldata;
    312
        }
    313
    
                                                    
                                                
    314
        // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`
    315
        // (slotValue & mask) >> offsetRight will be the value of the given packed variable
    316
        function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {
    317
            // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;
    318
            // using assembly because (1 << 256) causes overflow
    319
            assembly {
    320
                mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))
    321
            }
    322
        }
    323
    
                                                    
                                                
    324
        // Returns slot value with updated packed variable.
    325
        function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
    326
            internal
    327
            pure
    328
            returns (bytes32 newValue)
    329
        {
    330
            return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));
    331
        }
    332
    }
    333
    
                                                    
                                                
    334
    ✓ 15
    library stdStorage {
    335
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    336
    
                                                    
                                                
    337
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    338
            return stdStorageSafe.sigs(sigStr);
    339
        }
    340
    
                                                    
                                                
    341
        function find(StdStorage storage self) internal returns (uint256) {
    342
            return find(self, true);
    343
        }
    344
    
                                                    
                                                
    345
        function find(StdStorage storage self, bool _clear) internal returns (uint256) {
    346
            return stdStorageSafe.find(self, _clear).slot;
    347
        }
    348
    
                                                    
                                                
    349
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    350
            return stdStorageSafe.target(self, _target);
    351
        }
    352
    
                                                    
                                                
    353
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    354
            return stdStorageSafe.sig(self, _sig);
    355
        }
    356
    
                                                    
                                                
    357
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    358
            return stdStorageSafe.sig(self, _sig);
    359
        }
    360
    
                                                    
                                                
    361
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    362
            return stdStorageSafe.with_key(self, who);
    363
        }
    364
    
                                                    
                                                
    365
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    366
            return stdStorageSafe.with_key(self, amt);
    367
        }
    368
    
                                                    
                                                
    369
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    370
            return stdStorageSafe.with_key(self, key);
    371
        }
    372
    
                                                    
                                                
    373
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    374
            return stdStorageSafe.with_calldata(self, _calldata);
    375
        }
    376
    
                                                    
                                                
    377
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    378
            return stdStorageSafe.enable_packed_slots(self);
    379
        }
    380
    
                                                    
                                                
    381
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    382
            return stdStorageSafe.depth(self, _depth);
    383
        }
    384
    
                                                    
                                                
    385
        function clear(StdStorage storage self) internal {
    386
            stdStorageSafe.clear(self);
    387
        }
    388
    
                                                    
                                                
    389
        function checked_write(StdStorage storage self, address who) internal {
    390
            checked_write(self, bytes32(uint256(uint160(who))));
    391
        }
    392
    
                                                    
                                                
    393
        function checked_write(StdStorage storage self, uint256 amt) internal {
    394
            checked_write(self, bytes32(amt));
    395
        }
    396
    
                                                    
                                                
    397
        function checked_write_int(StdStorage storage self, int256 val) internal {
    398
            checked_write(self, bytes32(uint256(val)));
    399
        }
    400
    
                                                    
                                                
    401
        function checked_write(StdStorage storage self, bool write) internal {
    402
            bytes32 t;
    403
            /// @solidity memory-safe-assembly
    404
            assembly {
    405
                t := write
    406
            }
    407
            checked_write(self, t);
    408
        }
    409
    
                                                    
                                                
    410
        function checked_write(StdStorage storage self, bytes32 set) internal {
    411
            address who = self._target;
    412
            bytes4 fsig = self._sig;
    413
            uint256 field_depth = self._depth;
    414
            bytes memory params = stdStorageSafe.getCallParams(self);
    415
    
                                                    
                                                
    416
            if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    417
                find(self, false);
    418
            }
    419
            FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    420
            if ((data.offsetLeft + data.offsetRight) > 0) {
    421
                uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));
    422
                require(
    423
                    uint256(set) < maxVal,
    424
                    string(
    425
                        abi.encodePacked(
    426
                            "stdStorage find(StdStorage): Packed slot. We can't fit value greater than ",
    427
                            vm.toString(maxVal)
    428
                        )
    429
                    )
    430
                );
    431
            }
    432
            bytes32 curVal = vm.load(who, bytes32(data.slot));
    433
            bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);
    434
    
                                                    
                                                
    435
            vm.store(who, bytes32(data.slot), valToSet);
    436
    
                                                    
                                                
    437
            (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);
    438
    
                                                    
                                                
    439
            if (!success || callResult != set) {
    440
                vm.store(who, bytes32(data.slot), curVal);
    441
                revert("stdStorage find(StdStorage): Failed to write value.");
    442
            }
    443
            clear(self);
    444
        }
    445
    
                                                    
                                                
    446
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    447
            return stdStorageSafe.read_bytes32(self);
    448
        }
    449
    
                                                    
                                                
    450
        function read_bool(StdStorage storage self) internal returns (bool) {
    451
            return stdStorageSafe.read_bool(self);
    452
        }
    453
    
                                                    
                                                
    454
        function read_address(StdStorage storage self) internal returns (address) {
    455
            return stdStorageSafe.read_address(self);
    456
        }
    457
    
                                                    
                                                
    458
        function read_uint(StdStorage storage self) internal returns (uint256) {
    459
            return stdStorageSafe.read_uint(self);
    460
        }
    461
    
                                                    
                                                
    462
        function read_int(StdStorage storage self) internal returns (int256) {
    463
            return stdStorageSafe.read_int(self);
    464
        }
    465
    
                                                    
                                                
    466
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    467
            return stdStorageSafe.parent(self);
    468
        }
    469
    
                                                    
                                                
    470
        function root(StdStorage storage self) internal returns (uint256) {
    471
            return stdStorageSafe.root(self);
    472
        }
    473
    }
    474
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/StdStyle.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    import {VmSafe} from "./Vm.sol";
    5
    
                                                    
                                                
    6
    ✓ 15
    library StdStyle {
    7
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    8
    
                                                    
                                                
    9
        string constant RED = "\u001b[91m";
    10
        string constant GREEN = "\u001b[92m";
    11
        string constant YELLOW = "\u001b[93m";
    12
        string constant BLUE = "\u001b[94m";
    13
        string constant MAGENTA = "\u001b[95m";
    14
        string constant CYAN = "\u001b[96m";
    15
        string constant BOLD = "\u001b[1m";
    16
        string constant DIM = "\u001b[2m";
    17
        string constant ITALIC = "\u001b[3m";
    18
        string constant UNDERLINE = "\u001b[4m";
    19
        string constant INVERSE = "\u001b[7m";
    20
        string constant RESET = "\u001b[0m";
    21
    
                                                    
                                                
    22
        function styleConcat(string memory style, string memory self) private pure returns (string memory) {
    23
            return string(abi.encodePacked(style, self, RESET));
    24
        }
    25
    
                                                    
                                                
    26
        function red(string memory self) internal pure returns (string memory) {
    27
            return styleConcat(RED, self);
    28
        }
    29
    
                                                    
                                                
    30
        function red(uint256 self) internal pure returns (string memory) {
    31
            return red(vm.toString(self));
    32
        }
    33
    
                                                    
                                                
    34
        function red(int256 self) internal pure returns (string memory) {
    35
            return red(vm.toString(self));
    36
        }
    37
    
                                                    
                                                
    38
        function red(address self) internal pure returns (string memory) {
    39
            return red(vm.toString(self));
    40
        }
    41
    
                                                    
                                                
    42
        function red(bool self) internal pure returns (string memory) {
    43
            return red(vm.toString(self));
    44
        }
    45
    
                                                    
                                                
    46
        function redBytes(bytes memory self) internal pure returns (string memory) {
    47
            return red(vm.toString(self));
    48
        }
    49
    
                                                    
                                                
    50
        function redBytes32(bytes32 self) internal pure returns (string memory) {
    51
            return red(vm.toString(self));
    52
        }
    53
    
                                                    
                                                
    54
        function green(string memory self) internal pure returns (string memory) {
    55
            return styleConcat(GREEN, self);
    56
        }
    57
    
                                                    
                                                
    58
        function green(uint256 self) internal pure returns (string memory) {
    59
            return green(vm.toString(self));
    60
        }
    61
    
                                                    
                                                
    62
        function green(int256 self) internal pure returns (string memory) {
    63
            return green(vm.toString(self));
    64
        }
    65
    
                                                    
                                                
    66
        function green(address self) internal pure returns (string memory) {
    67
            return green(vm.toString(self));
    68
        }
    69
    
                                                    
                                                
    70
        function green(bool self) internal pure returns (string memory) {
    71
            return green(vm.toString(self));
    72
        }
    73
    
                                                    
                                                
    74
        function greenBytes(bytes memory self) internal pure returns (string memory) {
    75
            return green(vm.toString(self));
    76
        }
    77
    
                                                    
                                                
    78
        function greenBytes32(bytes32 self) internal pure returns (string memory) {
    79
            return green(vm.toString(self));
    80
        }
    81
    
                                                    
                                                
    82
        function yellow(string memory self) internal pure returns (string memory) {
    83
            return styleConcat(YELLOW, self);
    84
        }
    85
    
                                                    
                                                
    86
        function yellow(uint256 self) internal pure returns (string memory) {
    87
            return yellow(vm.toString(self));
    88
        }
    89
    
                                                    
                                                
    90
        function yellow(int256 self) internal pure returns (string memory) {
    91
            return yellow(vm.toString(self));
    92
        }
    93
    
                                                    
                                                
    94
        function yellow(address self) internal pure returns (string memory) {
    95
            return yellow(vm.toString(self));
    96
        }
    97
    
                                                    
                                                
    98
        function yellow(bool self) internal pure returns (string memory) {
    99
            return yellow(vm.toString(self));
    100
        }
    101
    
                                                    
                                                
    102
        function yellowBytes(bytes memory self) internal pure returns (string memory) {
    103
            return yellow(vm.toString(self));
    104
        }
    105
    
                                                    
                                                
    106
        function yellowBytes32(bytes32 self) internal pure returns (string memory) {
    107
            return yellow(vm.toString(self));
    108
        }
    109
    
                                                    
                                                
    110
        function blue(string memory self) internal pure returns (string memory) {
    111
            return styleConcat(BLUE, self);
    112
        }
    113
    
                                                    
                                                
    114
        function blue(uint256 self) internal pure returns (string memory) {
    115
            return blue(vm.toString(self));
    116
        }
    117
    
                                                    
                                                
    118
        function blue(int256 self) internal pure returns (string memory) {
    119
            return blue(vm.toString(self));
    120
        }
    121
    
                                                    
                                                
    122
        function blue(address self) internal pure returns (string memory) {
    123
            return blue(vm.toString(self));
    124
        }
    125
    
                                                    
                                                
    126
        function blue(bool self) internal pure returns (string memory) {
    127
            return blue(vm.toString(self));
    128
        }
    129
    
                                                    
                                                
    130
        function blueBytes(bytes memory self) internal pure returns (string memory) {
    131
            return blue(vm.toString(self));
    132
        }
    133
    
                                                    
                                                
    134
        function blueBytes32(bytes32 self) internal pure returns (string memory) {
    135
            return blue(vm.toString(self));
    136
        }
    137
    
                                                    
                                                
    138
        function magenta(string memory self) internal pure returns (string memory) {
    139
            return styleConcat(MAGENTA, self);
    140
        }
    141
    
                                                    
                                                
    142
        function magenta(uint256 self) internal pure returns (string memory) {
    143
            return magenta(vm.toString(self));
    144
        }
    145
    
                                                    
                                                
    146
        function magenta(int256 self) internal pure returns (string memory) {
    147
            return magenta(vm.toString(self));
    148
        }
    149
    
                                                    
                                                
    150
        function magenta(address self) internal pure returns (string memory) {
    151
            return magenta(vm.toString(self));
    152
        }
    153
    
                                                    
                                                
    154
        function magenta(bool self) internal pure returns (string memory) {
    155
            return magenta(vm.toString(self));
    156
        }
    157
    
                                                    
                                                
    158
        function magentaBytes(bytes memory self) internal pure returns (string memory) {
    159
            return magenta(vm.toString(self));
    160
        }
    161
    
                                                    
                                                
    162
        function magentaBytes32(bytes32 self) internal pure returns (string memory) {
    163
            return magenta(vm.toString(self));
    164
        }
    165
    
                                                    
                                                
    166
        function cyan(string memory self) internal pure returns (string memory) {
    167
            return styleConcat(CYAN, self);
    168
        }
    169
    
                                                    
                                                
    170
        function cyan(uint256 self) internal pure returns (string memory) {
    171
            return cyan(vm.toString(self));
    172
        }
    173
    
                                                    
                                                
    174
        function cyan(int256 self) internal pure returns (string memory) {
    175
            return cyan(vm.toString(self));
    176
        }
    177
    
                                                    
                                                
    178
        function cyan(address self) internal pure returns (string memory) {
    179
            return cyan(vm.toString(self));
    180
        }
    181
    
                                                    
                                                
    182
        function cyan(bool self) internal pure returns (string memory) {
    183
            return cyan(vm.toString(self));
    184
        }
    185
    
                                                    
                                                
    186
        function cyanBytes(bytes memory self) internal pure returns (string memory) {
    187
            return cyan(vm.toString(self));
    188
        }
    189
    
                                                    
                                                
    190
        function cyanBytes32(bytes32 self) internal pure returns (string memory) {
    191
            return cyan(vm.toString(self));
    192
        }
    193
    
                                                    
                                                
    194
        function bold(string memory self) internal pure returns (string memory) {
    195
            return styleConcat(BOLD, self);
    196
        }
    197
    
                                                    
                                                
    198
        function bold(uint256 self) internal pure returns (string memory) {
    199
            return bold(vm.toString(self));
    200
        }
    201
    
                                                    
                                                
    202
        function bold(int256 self) internal pure returns (string memory) {
    203
            return bold(vm.toString(self));
    204
        }
    205
    
                                                    
                                                
    206
        function bold(address self) internal pure returns (string memory) {
    207
            return bold(vm.toString(self));
    208
        }
    209
    
                                                    
                                                
    210
        function bold(bool self) internal pure returns (string memory) {
    211
            return bold(vm.toString(self));
    212
        }
    213
    
                                                    
                                                
    214
        function boldBytes(bytes memory self) internal pure returns (string memory) {
    215
            return bold(vm.toString(self));
    216
        }
    217
    
                                                    
                                                
    218
        function boldBytes32(bytes32 self) internal pure returns (string memory) {
    219
            return bold(vm.toString(self));
    220
        }
    221
    
                                                    
                                                
    222
        function dim(string memory self) internal pure returns (string memory) {
    223
            return styleConcat(DIM, self);
    224
        }
    225
    
                                                    
                                                
    226
        function dim(uint256 self) internal pure returns (string memory) {
    227
            return dim(vm.toString(self));
    228
        }
    229
    
                                                    
                                                
    230
        function dim(int256 self) internal pure returns (string memory) {
    231
            return dim(vm.toString(self));
    232
        }
    233
    
                                                    
                                                
    234
        function dim(address self) internal pure returns (string memory) {
    235
            return dim(vm.toString(self));
    236
        }
    237
    
                                                    
                                                
    238
        function dim(bool self) internal pure returns (string memory) {
    239
            return dim(vm.toString(self));
    240
        }
    241
    
                                                    
                                                
    242
        function dimBytes(bytes memory self) internal pure returns (string memory) {
    243
            return dim(vm.toString(self));
    244
        }
    245
    
                                                    
                                                
    246
        function dimBytes32(bytes32 self) internal pure returns (string memory) {
    247
            return dim(vm.toString(self));
    248
        }
    249
    
                                                    
                                                
    250
        function italic(string memory self) internal pure returns (string memory) {
    251
            return styleConcat(ITALIC, self);
    252
        }
    253
    
                                                    
                                                
    254
        function italic(uint256 self) internal pure returns (string memory) {
    255
            return italic(vm.toString(self));
    256
        }
    257
    
                                                    
                                                
    258
        function italic(int256 self) internal pure returns (string memory) {
    259
            return italic(vm.toString(self));
    260
        }
    261
    
                                                    
                                                
    262
        function italic(address self) internal pure returns (string memory) {
    263
            return italic(vm.toString(self));
    264
        }
    265
    
                                                    
                                                
    266
        function italic(bool self) internal pure returns (string memory) {
    267
            return italic(vm.toString(self));
    268
        }
    269
    
                                                    
                                                
    270
        function italicBytes(bytes memory self) internal pure returns (string memory) {
    271
            return italic(vm.toString(self));
    272
        }
    273
    
                                                    
                                                
    274
        function italicBytes32(bytes32 self) internal pure returns (string memory) {
    275
            return italic(vm.toString(self));
    276
        }
    277
    
                                                    
                                                
    278
        function underline(string memory self) internal pure returns (string memory) {
    279
            return styleConcat(UNDERLINE, self);
    280
        }
    281
    
                                                    
                                                
    282
        function underline(uint256 self) internal pure returns (string memory) {
    283
            return underline(vm.toString(self));
    284
        }
    285
    
                                                    
                                                
    286
        function underline(int256 self) internal pure returns (string memory) {
    287
            return underline(vm.toString(self));
    288
        }
    289
    
                                                    
                                                
    290
        function underline(address self) internal pure returns (string memory) {
    291
            return underline(vm.toString(self));
    292
        }
    293
    
                                                    
                                                
    294
        function underline(bool self) internal pure returns (string memory) {
    295
            return underline(vm.toString(self));
    296
        }
    297
    
                                                    
                                                
    298
        function underlineBytes(bytes memory self) internal pure returns (string memory) {
    299
            return underline(vm.toString(self));
    300
        }
    301
    
                                                    
                                                
    302
        function underlineBytes32(bytes32 self) internal pure returns (string memory) {
    303
            return underline(vm.toString(self));
    304
        }
    305
    
                                                    
                                                
    306
        function inverse(string memory self) internal pure returns (string memory) {
    307
            return styleConcat(INVERSE, self);
    308
        }
    309
    
                                                    
                                                
    310
        function inverse(uint256 self) internal pure returns (string memory) {
    311
            return inverse(vm.toString(self));
    312
        }
    313
    
                                                    
                                                
    314
        function inverse(int256 self) internal pure returns (string memory) {
    315
            return inverse(vm.toString(self));
    316
        }
    317
    
                                                    
                                                
    318
        function inverse(address self) internal pure returns (string memory) {
    319
            return inverse(vm.toString(self));
    320
        }
    321
    
                                                    
                                                
    322
        function inverse(bool self) internal pure returns (string memory) {
    323
            return inverse(vm.toString(self));
    324
        }
    325
    
                                                    
                                                
    326
        function inverseBytes(bytes memory self) internal pure returns (string memory) {
    327
            return inverse(vm.toString(self));
    328
        }
    329
    
                                                    
                                                
    330
        function inverseBytes32(bytes32 self) internal pure returns (string memory) {
    331
            return inverse(vm.toString(self));
    332
        }
    333
    }
    334
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/StdToml.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {VmSafe} from "./Vm.sol";
    7
    
                                                    
                                                
    8
    // Helpers for parsing and writing TOML files
    9
    // To parse:
    10
    // ```
    11
    // using stdToml for string;
    12
    // string memory toml = vm.readFile("<some_path>");
    13
    // toml.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdToml for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    
                                                    
                                                
    25
    ✓ 15
    library stdToml {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    
                                                    
                                                
    28
        function keyExists(string memory toml, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsToml(toml, key);
    30
        }
    31
    
                                                    
                                                
    32
        function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseToml(toml, key);
    34
        }
    35
    
                                                    
                                                
    36
        function readUint(string memory toml, string memory key) internal pure returns (uint256) {
    37
            return vm.parseTomlUint(toml, key);
    38
        }
    39
    
                                                    
                                                
    40
        function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseTomlUintArray(toml, key);
    42
        }
    43
    
                                                    
                                                
    44
        function readInt(string memory toml, string memory key) internal pure returns (int256) {
    45
            return vm.parseTomlInt(toml, key);
    46
        }
    47
    
                                                    
                                                
    48
        function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseTomlIntArray(toml, key);
    50
        }
    51
    
                                                    
                                                
    52
        function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseTomlBytes32(toml, key);
    54
        }
    55
    
                                                    
                                                
    56
        function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseTomlBytes32Array(toml, key);
    58
        }
    59
    
                                                    
                                                
    60
        function readString(string memory toml, string memory key) internal pure returns (string memory) {
    61
            return vm.parseTomlString(toml, key);
    62
        }
    63
    
                                                    
                                                
    64
        function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseTomlStringArray(toml, key);
    66
        }
    67
    
                                                    
                                                
    68
        function readAddress(string memory toml, string memory key) internal pure returns (address) {
    69
            return vm.parseTomlAddress(toml, key);
    70
        }
    71
    
                                                    
                                                
    72
        function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseTomlAddressArray(toml, key);
    74
        }
    75
    
                                                    
                                                
    76
        function readBool(string memory toml, string memory key) internal pure returns (bool) {
    77
            return vm.parseTomlBool(toml, key);
    78
        }
    79
    
                                                    
                                                
    80
        function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseTomlBoolArray(toml, key);
    82
        }
    83
    
                                                    
                                                
    84
        function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseTomlBytes(toml, key);
    86
        }
    87
    
                                                    
                                                
    88
        function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseTomlBytesArray(toml, key);
    90
        }
    91
    
                                                    
                                                
    92
        function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(toml, key) ? readUint(toml, key) : defaultValue;
    94
        }
    95
    
                                                    
                                                
    96
        function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue;
    102
        }
    103
    
                                                    
                                                
    104
        function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(toml, key) ? readInt(toml, key) : defaultValue;
    106
        }
    107
    
                                                    
                                                
    108
        function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue;
    114
        }
    115
    
                                                    
                                                
    116
        function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue;
    122
        }
    123
    
                                                    
                                                
    124
        function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue;
    130
        }
    131
    
                                                    
                                                
    132
        function readStringOr(string memory toml, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(toml, key) ? readString(toml, key) : defaultValue;
    138
        }
    139
    
                                                    
                                                
    140
        function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue;
    146
        }
    147
    
                                                    
                                                
    148
        function readAddressOr(string memory toml, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(toml, key) ? readAddress(toml, key) : defaultValue;
    154
        }
    155
    
                                                    
                                                
    156
        function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue;
    162
        }
    163
    
                                                    
                                                
    164
        function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(toml, key) ? readBool(toml, key) : defaultValue;
    166
        }
    167
    
                                                    
                                                
    168
        function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue;
    174
        }
    175
    
                                                    
                                                
    176
        function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(toml, key) ? readBytes(toml, key) : defaultValue;
    182
        }
    183
    
                                                    
                                                
    184
        function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue;
    190
        }
    191
    
                                                    
                                                
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    
                                                    
                                                
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    
                                                    
                                                
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value)
    201
            internal
    202
            returns (string memory)
    203
        {
    204
            return vm.serializeBool(jsonKey, key, value);
    205
        }
    206
    
                                                    
                                                
    207
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    208
            return vm.serializeUint(jsonKey, key, value);
    209
        }
    210
    
                                                    
                                                
    211
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    212
            internal
    213
            returns (string memory)
    214
        {
    215
            return vm.serializeUint(jsonKey, key, value);
    216
        }
    217
    
                                                    
                                                
    218
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    219
            return vm.serializeInt(jsonKey, key, value);
    220
        }
    221
    
                                                    
                                                
    222
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    223
            internal
    224
            returns (string memory)
    225
        {
    226
            return vm.serializeInt(jsonKey, key, value);
    227
        }
    228
    
                                                    
                                                
    229
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    230
            return vm.serializeAddress(jsonKey, key, value);
    231
        }
    232
    
                                                    
                                                
    233
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    234
            internal
    235
            returns (string memory)
    236
        {
    237
            return vm.serializeAddress(jsonKey, key, value);
    238
        }
    239
    
                                                    
                                                
    240
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    241
            return vm.serializeBytes32(jsonKey, key, value);
    242
        }
    243
    
                                                    
                                                
    244
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    245
            internal
    246
            returns (string memory)
    247
        {
    248
            return vm.serializeBytes32(jsonKey, key, value);
    249
        }
    250
    
                                                    
                                                
    251
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    252
            return vm.serializeBytes(jsonKey, key, value);
    253
        }
    254
    
                                                    
                                                
    255
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    256
            internal
    257
            returns (string memory)
    258
        {
    259
            return vm.serializeBytes(jsonKey, key, value);
    260
        }
    261
    
                                                    
                                                
    262
        function serialize(string memory jsonKey, string memory key, string memory value)
    263
            internal
    264
            returns (string memory)
    265
        {
    266
            return vm.serializeString(jsonKey, key, value);
    267
        }
    268
    
                                                    
                                                
    269
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    270
            internal
    271
            returns (string memory)
    272
        {
    273
            return vm.serializeString(jsonKey, key, value);
    274
        }
    275
    
                                                    
                                                
    276
        function write(string memory jsonKey, string memory path) internal {
    277
            vm.writeToml(jsonKey, path);
    278
        }
    279
    
                                                    
                                                
    280
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    281
            vm.writeToml(jsonKey, path, valueKey);
    282
        }
    283
    }
    284
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/StdUtils.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    import {IMulticall3} from "./interfaces/IMulticall3.sol";
    7
    import {VmSafe} from "./Vm.sol";
    8
    
                                                    
                                                
    9
    abstract contract StdUtils {
    10
        /*//////////////////////////////////////////////////////////////////////////
    11
                                         CONSTANTS
    12
        //////////////////////////////////////////////////////////////////////////*/
    13
    
                                                    
                                                
    14
        IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
    15
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    16
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    17
        uint256 private constant INT256_MIN_ABS =
    18
            57896044618658097711785492504343953926634992332820282019728792003956564819968;
    19
        uint256 private constant SECP256K1_ORDER =
    20
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    21
        uint256 private constant UINT256_MAX =
    22
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    23
    
                                                    
                                                
    24
        // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
    25
        address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    26
    
                                                    
                                                
    27
        /*//////////////////////////////////////////////////////////////////////////
    28
                                     INTERNAL FUNCTIONS
    29
        //////////////////////////////////////////////////////////////////////////*/
    30
    
                                                    
                                                
    31
        function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    32
            require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
    33
            // If x is between min and max, return x directly. This is to ensure that dictionary values
    34
            // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
    35
            if (x >= min && x <= max) return x;
    36
    
                                                    
                                                
    37
            uint256 size = max - min + 1;
    38
    
                                                    
                                                
    39
            // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.
    40
            // This helps ensure coverage of the min/max values.
    41
            if (x <= 3 && size > x) return min + x;
    42
            if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);
    43
    
                                                    
                                                
    44
            // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
    45
            if (x > max) {
    46
                uint256 diff = x - max;
    47
                uint256 rem = diff % size;
    48
                if (rem == 0) return max;
    49
                result = min + rem - 1;
    50
            } else if (x < min) {
    51
                uint256 diff = min - x;
    52
                uint256 rem = diff % size;
    53
                if (rem == 0) return min;
    54
                result = max - rem + 1;
    55
            }
    56
        }
    57
    
                                                    
                                                
    58
        function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    59
            result = _bound(x, min, max);
    60
            console2_log_StdUtils("Bound result", result);
    61
        }
    62
    
                                                    
                                                
    63
        function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    64
            require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
    65
    
                                                    
                                                
    66
            // Shifting all int256 values to uint256 to use _bound function. The range of two types are:
    67
            // int256 : -(2**255) ~ (2**255 - 1)
    68
            // uint256:     0     ~ (2**256 - 1)
    69
            // So, add 2**255, INT256_MIN_ABS to the integer values.
    70
            //
    71
            // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
    72
            // So, use `~uint256(x) + 1` instead.
    73
            uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);
    74
            uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);
    75
            uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);
    76
    
                                                    
                                                
    77
            uint256 y = _bound(_x, _min, _max);
    78
    
                                                    
                                                
    79
            // To move it back to int256 value, subtract INT256_MIN_ABS at here.
    80
            result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);
    81
        }
    82
    
                                                    
                                                
    83
        function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    84
            result = _bound(x, min, max);
    85
            console2_log_StdUtils("Bound result", vm.toString(result));
    86
        }
    87
    
                                                    
                                                
    88
        function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
    89
            result = _bound(privateKey, 1, SECP256K1_ORDER - 1);
    90
        }
    91
    
                                                    
                                                
    92
        function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
    93
            require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
    94
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    95
        }
    96
    
                                                    
                                                
    97
        /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce
    98
        /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)
    99
        function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
    100
            console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
    101
            return vm.computeCreateAddress(deployer, nonce);
    102
        }
    103
    
                                                    
                                                
    104
        function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
    105
            internal
    106
            pure
    107
            virtual
    108
            returns (address)
    109
        {
    110
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    111
            return vm.computeCreate2Address(salt, initcodeHash, deployer);
    112
        }
    113
    
                                                    
                                                
    114
        /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer
    115
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
    116
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    117
            return vm.computeCreate2Address(salt, initCodeHash);
    118
        }
    119
    
                                                    
                                                
    120
        /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments
    121
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    122
        function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
    123
            return hashInitCode(creationCode, "");
    124
        }
    125
    
                                                    
                                                
    126
        /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2
    127
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    128
        /// @param args the ABI-encoded arguments to the constructor of C
    129
        function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
    130
            return keccak256(abi.encodePacked(creationCode, args));
    131
        }
    132
    
                                                    
                                                
    133
        // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.
    134
        function getTokenBalances(address token, address[] memory addresses)
    135
            internal
    136
            virtual
    137
            returns (uint256[] memory balances)
    138
        {
    139
            uint256 tokenCodeSize;
    140
            assembly {
    141
                tokenCodeSize := extcodesize(token)
    142
            }
    143
            require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
    144
    
                                                    
                                                
    145
            // ABI encode the aggregate call to Multicall3.
    146
            uint256 length = addresses.length;
    147
            IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
    148
            for (uint256 i = 0; i < length; ++i) {
    149
                // 0x70a08231 = bytes4("balanceOf(address)"))
    150
                calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
    151
            }
    152
    
                                                    
                                                
    153
            // Make the aggregate call.
    154
            (, bytes[] memory returnData) = multicall.aggregate(calls);
    155
    
                                                    
                                                
    156
            // ABI decode the return data and return the balances.
    157
            balances = new uint256[](length);
    158
            for (uint256 i = 0; i < length; ++i) {
    159
                balances[i] = abi.decode(returnData[i], (uint256));
    160
            }
    161
        }
    162
    
                                                    
                                                
    163
        /*//////////////////////////////////////////////////////////////////////////
    164
                                     PRIVATE FUNCTIONS
    165
        //////////////////////////////////////////////////////////////////////////*/
    166
    
                                                    
                                                
    167
        function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
    168
            return address(uint160(uint256(bytesValue)));
    169
        }
    170
    
                                                    
                                                
    171
        // This section is used to prevent the compilation of console, which shortens the compilation time when console is
    172
        // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
    173
        // any breaking changes to function signatures.
    174
        function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
    175
            internal
    176
            pure
    177
            returns (function(bytes memory) internal pure fnOut)
    178
        {
    179
            assembly {
    180
                fnOut := fnIn
    181
            }
    182
        }
    183
    
                                                    
                                                
    184
        function _sendLogPayload(bytes memory payload) internal pure {
    185
            _castLogPayloadViewToPure(_sendLogPayloadView)(payload);
    186
        }
    187
    
                                                    
                                                
    188
        function _sendLogPayloadView(bytes memory payload) private view {
    189
            uint256 payloadLength = payload.length;
    190
            address consoleAddress = CONSOLE2_ADDRESS;
    191
            /// @solidity memory-safe-assembly
    192
            assembly {
    193
                let payloadStart := add(payload, 32)
    194
                let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
    195
            }
    196
        }
    197
    
                                                    
                                                
    198
        function console2_log_StdUtils(string memory p0) private pure {
    199
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    200
        }
    201
    
                                                    
                                                
    202
        function console2_log_StdUtils(string memory p0, uint256 p1) private pure {
    203
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    204
        }
    205
    
                                                    
                                                
    206
        function console2_log_StdUtils(string memory p0, string memory p1) private pure {
    207
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    208
        }
    209
    }
    210
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/Test.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    // 💬 ABOUT
    7
    // Forge Std's default Test.
    8
    
                                                    
                                                
    9
    // 🧩 MODULES
    10
    import {console} from "./console.sol";
    11
    import {console2} from "./console2.sol";
    12
    import {safeconsole} from "./safeconsole.sol";
    13
    import {StdAssertions} from "./StdAssertions.sol";
    14
    import {StdChains} from "./StdChains.sol";
    15
    import {StdCheats} from "./StdCheats.sol";
    16
    import {stdError} from "./StdError.sol";
    17
    import {StdInvariant} from "./StdInvariant.sol";
    18
    import {stdJson} from "./StdJson.sol";
    19
    import {stdMath} from "./StdMath.sol";
    20
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    21
    import {StdStyle} from "./StdStyle.sol";
    22
    import {stdToml} from "./StdToml.sol";
    23
    import {StdUtils} from "./StdUtils.sol";
    24
    import {Vm} from "./Vm.sol";
    25
    
                                                    
                                                
    26
    // 📦 BOILERPLATE
    27
    import {TestBase} from "./Base.sol";
    28
    
                                                    
                                                
    29
    // ⭐️ TEST
    30
    abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
    31
        // Note: IS_TEST() must return true.
    32
        bool public IS_TEST = true;
    33
    }
    34
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/Vm.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // Automatically @generated by scripts/vm.py. Do not modify manually.
    2
    
                                                    
                                                
    3
    // SPDX-License-Identifier: MIT OR Apache-2.0
    4
    pragma solidity >=0.6.2 <0.9.0;
    5
    pragma experimental ABIEncoderV2;
    6
    
                                                    
                                                
    7
    /// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
    8
    /// result in Script simulations differing from on-chain execution. It is recommended to only use
    9
    /// these cheats in scripts.
    10
    interface VmSafe {
    11
        /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.
    12
        enum CallerMode {
    13
            // No caller modification is currently active.
    14
            None,
    15
            // A one time broadcast triggered by a `vm.broadcast()` call is currently active.
    16
            Broadcast,
    17
            // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.
    18
            RecurrentBroadcast,
    19
            // A one time prank triggered by a `vm.prank()` call is currently active.
    20
            Prank,
    21
            // A recurrent prank triggered by a `vm.startPrank()` call is currently active.
    22
            RecurrentPrank
    23
        }
    24
    
                                                    
                                                
    25
        /// The kind of account access that occurred.
    26
        enum AccountAccessKind {
    27
            // The account was called.
    28
            Call,
    29
            // The account was called via delegatecall.
    30
            DelegateCall,
    31
            // The account was called via callcode.
    32
            CallCode,
    33
            // The account was called via staticcall.
    34
            StaticCall,
    35
            // The account was created.
    36
            Create,
    37
            // The account was selfdestructed.
    38
            SelfDestruct,
    39
            // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).
    40
            Resume,
    41
            // The account's balance was read.
    42
            Balance,
    43
            // The account's codesize was read.
    44
            Extcodesize,
    45
            // The account's codehash was read.
    46
            Extcodehash,
    47
            // The account's code was copied.
    48
            Extcodecopy
    49
        }
    50
    
                                                    
                                                
    51
        /// Forge execution contexts.
    52
        enum ForgeContext {
    53
            // Test group execution context (test, coverage or snapshot).
    54
            TestGroup,
    55
            // `forge test` execution context.
    56
            Test,
    57
            // `forge coverage` execution context.
    58
            Coverage,
    59
            // `forge snapshot` execution context.
    60
            Snapshot,
    61
            // Script group execution context (dry run, broadcast or resume).
    62
            ScriptGroup,
    63
            // `forge script` execution context.
    64
            ScriptDryRun,
    65
            // `forge script --broadcast` execution context.
    66
            ScriptBroadcast,
    67
            // `forge script --resume` execution context.
    68
            ScriptResume,
    69
            // Unknown `forge` execution context.
    70
            Unknown
    71
        }
    72
    
                                                    
                                                
    73
        /// The transaction type (`txType`) of the broadcast.
    74
        enum BroadcastTxType {
    75
            // Represents a CALL broadcast tx.
    76
            Call,
    77
            // Represents a CREATE broadcast tx.
    78
            Create,
    79
            // Represents a CREATE2 broadcast tx.
    80
            Create2
    81
        }
    82
    
                                                    
                                                
    83
        /// An Ethereum log. Returned by `getRecordedLogs`.
    84
        struct Log {
    85
            // The topics of the log, including the signature, if any.
    86
            bytes32[] topics;
    87
            // The raw data of the log.
    88
            bytes data;
    89
            // The address of the log's emitter.
    90
            address emitter;
    91
        }
    92
    
                                                    
                                                
    93
        /// An RPC URL and its alias. Returned by `rpcUrlStructs`.
    94
        struct Rpc {
    95
            // The alias of the RPC URL.
    96
            string key;
    97
            // The RPC URL.
    98
            string url;
    99
        }
    100
    
                                                    
                                                
    101
        /// An RPC log object. Returned by `eth_getLogs`.
    102
        struct EthGetLogs {
    103
            // The address of the log's emitter.
    104
            address emitter;
    105
            // The topics of the log, including the signature, if any.
    106
            bytes32[] topics;
    107
            // The raw data of the log.
    108
            bytes data;
    109
            // The block hash.
    110
            bytes32 blockHash;
    111
            // The block number.
    112
            uint64 blockNumber;
    113
            // The transaction hash.
    114
            bytes32 transactionHash;
    115
            // The transaction index in the block.
    116
            uint64 transactionIndex;
    117
            // The log index.
    118
            uint256 logIndex;
    119
            // Whether the log was removed.
    120
            bool removed;
    121
        }
    122
    
                                                    
                                                
    123
        /// A single entry in a directory listing. Returned by `readDir`.
    124
        struct DirEntry {
    125
            // The error message, if any.
    126
            string errorMessage;
    127
            // The path of the entry.
    128
            string path;
    129
            // The depth of the entry.
    130
            uint64 depth;
    131
            // Whether the entry is a directory.
    132
            bool isDir;
    133
            // Whether the entry is a symlink.
    134
            bool isSymlink;
    135
        }
    136
    
                                                    
                                                
    137
        /// Metadata information about a file.
    138
        /// This structure is returned from the `fsMetadata` function and represents known
    139
        /// metadata about a file such as its permissions, size, modification
    140
        /// times, etc.
    141
        struct FsMetadata {
    142
            // True if this metadata is for a directory.
    143
            bool isDir;
    144
            // True if this metadata is for a symlink.
    145
            bool isSymlink;
    146
            // The size of the file, in bytes, this metadata is for.
    147
            uint256 length;
    148
            // True if this metadata is for a readonly (unwritable) file.
    149
            bool readOnly;
    150
            // The last modification time listed in this metadata.
    151
            uint256 modified;
    152
            // The last access time of this metadata.
    153
            uint256 accessed;
    154
            // The creation time listed in this metadata.
    155
            uint256 created;
    156
        }
    157
    
                                                    
                                                
    158
        /// A wallet with a public and private key.
    159
        struct Wallet {
    160
            // The wallet's address.
    161
            address addr;
    162
            // The wallet's public key `X`.
    163
            uint256 publicKeyX;
    164
            // The wallet's public key `Y`.
    165
            uint256 publicKeyY;
    166
            // The wallet's private key.
    167
            uint256 privateKey;
    168
        }
    169
    
                                                    
                                                
    170
        /// The result of a `tryFfi` call.
    171
        struct FfiResult {
    172
            // The exit code of the call.
    173
            int32 exitCode;
    174
            // The optionally hex-decoded `stdout` data.
    175
            bytes stdout;
    176
            // The `stderr` data.
    177
            bytes stderr;
    178
        }
    179
    
                                                    
                                                
    180
        /// Information on the chain and fork.
    181
        struct ChainInfo {
    182
            // The fork identifier. Set to zero if no fork is active.
    183
            uint256 forkId;
    184
            // The chain ID of the current fork.
    185
            uint256 chainId;
    186
        }
    187
    
                                                    
                                                
    188
        /// The result of a `stopAndReturnStateDiff` call.
    189
        struct AccountAccess {
    190
            // The chain and fork the access occurred.
    191
            ChainInfo chainInfo;
    192
            // The kind of account access that determines what the account is.
    193
            // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.
    194
            // If kind is Create, then the account is the newly created account.
    195
            // If kind is SelfDestruct, then the account is the selfdestruct recipient.
    196
            // If kind is a Resume, then account represents a account context that has resumed.
    197
            AccountAccessKind kind;
    198
            // The account that was accessed.
    199
            // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.
    200
            address account;
    201
            // What accessed the account.
    202
            address accessor;
    203
            // If the account was initialized or empty prior to the access.
    204
            // An account is considered initialized if it has code, a
    205
            // non-zero nonce, or a non-zero balance.
    206
            bool initialized;
    207
            // The previous balance of the accessed account.
    208
            uint256 oldBalance;
    209
            // The potential new balance of the accessed account.
    210
            // That is, all balance changes are recorded here, even if reverts occurred.
    211
            uint256 newBalance;
    212
            // Code of the account deployed by CREATE.
    213
            bytes deployedCode;
    214
            // Value passed along with the account access
    215
            uint256 value;
    216
            // Input data provided to the CREATE or CALL
    217
            bytes data;
    218
            // If this access reverted in either the current or parent context.
    219
            bool reverted;
    220
            // An ordered list of storage accesses made during an account access operation.
    221
            StorageAccess[] storageAccesses;
    222
            // Call depth traversed during the recording of state differences
    223
            uint64 depth;
    224
        }
    225
    
                                                    
                                                
    226
        /// The storage accessed during an `AccountAccess`.
    227
        struct StorageAccess {
    228
            // The account whose storage was accessed.
    229
            address account;
    230
            // The slot that was accessed.
    231
            bytes32 slot;
    232
            // If the access was a write.
    233
            bool isWrite;
    234
            // The previous value of the slot.
    235
            bytes32 previousValue;
    236
            // The new value of the slot.
    237
            bytes32 newValue;
    238
            // If the access was reverted.
    239
            bool reverted;
    240
        }
    241
    
                                                    
                                                
    242
        /// Gas used. Returned by `lastCallGas`.
    243
        struct Gas {
    244
            // The gas limit of the call.
    245
            uint64 gasLimit;
    246
            // The total gas used.
    247
            uint64 gasTotalUsed;
    248
            // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939>
    249
            uint64 gasMemoryUsed;
    250
            // The amount of gas refunded.
    251
            int64 gasRefunded;
    252
            // The amount of gas remaining.
    253
            uint64 gasRemaining;
    254
        }
    255
    
                                                    
                                                
    256
        /// The result of the `stopDebugTraceRecording` call
    257
        struct DebugStep {
    258
            // The stack before executing the step of the run.
    259
            // stack\[0\] represents the top of the stack.
    260
            // and only stack data relevant to the opcode execution is contained.
    261
            uint256[] stack;
    262
            // The memory input data before executing the step of the run.
    263
            // only input data relevant to the opcode execution is contained.
    264
            // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here.
    265
            // the offset value can be get by the stack data.
    266
            bytes memoryInput;
    267
            // The opcode that was accessed.
    268
            uint8 opcode;
    269
            // The call depth of the step.
    270
            uint64 depth;
    271
            // Whether the call end up with out of gas error.
    272
            bool isOutOfGas;
    273
            // The contract address where the opcode is running
    274
            address contractAddr;
    275
        }
    276
    
                                                    
                                                
    277
        /// Represents a transaction's broadcast details.
    278
        struct BroadcastTxSummary {
    279
            // The hash of the transaction that was broadcasted
    280
            bytes32 txHash;
    281
            // Represent the type of transaction among CALL, CREATE, CREATE2
    282
            BroadcastTxType txType;
    283
            // The address of the contract that was called or created.
    284
            // This is address of the contract that is created if the txType is CREATE or CREATE2.
    285
            address contractAddress;
    286
            // The block number the transaction landed in.
    287
            uint64 blockNumber;
    288
            // Status of the transaction, retrieved from the transaction receipt.
    289
            bool success;
    290
        }
    291
    
                                                    
                                                
    292
        /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.
    293
        struct SignedDelegation {
    294
            // The y-parity of the recovered secp256k1 signature (0 or 1).
    295
            uint8 v;
    296
            // First 32 bytes of the signature.
    297
            bytes32 r;
    298
            // Second 32 bytes of the signature.
    299
            bytes32 s;
    300
            // The current nonce of the authority account at signing time.
    301
            // Used to ensure signature can't be replayed after account nonce changes.
    302
            uint64 nonce;
    303
            // Address of the contract implementation that will be delegated to.
    304
            // Gets encoded into delegation code: 0xef0100 || implementation.
    305
            address implementation;
    306
        }
    307
    
                                                    
                                                
    308
        /// Represents a "potential" revert reason from a single subsequent call when using `vm.assumeNoReverts`.
    309
        /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced
    310
        /// as normal.
    311
        struct PotentialRevert {
    312
            // The allowed origin of the revert opcode; address(0) allows reverts from any address
    313
            address reverter;
    314
            // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data
    315
            bool partialMatch;
    316
            // The data to use to match encountered reverts
    317
            bytes revertData;
    318
        }
    319
    
                                                    
                                                
    320
        // ======== Crypto ========
    321
    
                                                    
                                                
    322
        /// Derives a private key from the name, labels the account with that name, and returns the wallet.
    323
        function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);
    324
    
                                                    
                                                
    325
        /// Generates a wallet from the private key and returns the wallet.
    326
        function createWallet(uint256 privateKey) external returns (Wallet memory wallet);
    327
    
                                                    
                                                
    328
        /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.
    329
        function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);
    330
    
                                                    
                                                
    331
        /// Derive a private key from a provided mnenomic string (or mnenomic file path)
    332
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    333
        function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);
    334
    
                                                    
                                                
    335
        /// Derive a private key from a provided mnenomic string (or mnenomic file path)
    336
        /// at `{derivationPath}{index}`.
    337
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
    338
            external
    339
            pure
    340
            returns (uint256 privateKey);
    341
    
                                                    
                                                
    342
        /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
    343
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    344
        function deriveKey(string calldata mnemonic, uint32 index, string calldata language)
    345
            external
    346
            pure
    347
            returns (uint256 privateKey);
    348
    
                                                    
                                                
    349
        /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
    350
        /// at `{derivationPath}{index}`.
    351
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)
    352
            external
    353
            pure
    354
            returns (uint256 privateKey);
    355
    
                                                    
                                                
    356
        /// Derives secp256r1 public key from the provided `privateKey`.
    357
        function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);
    358
    
                                                    
                                                
    359
        /// Adds a private key to the local forge wallet and returns the address.
    360
        function rememberKey(uint256 privateKey) external returns (address keyAddr);
    361
    
                                                    
                                                
    362
        /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.
    363
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    364
        function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)
    365
            external
    366
            returns (address[] memory keyAddrs);
    367
    
                                                    
                                                
    368
        /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.
    369
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    370
        function rememberKeys(
    371
            string calldata mnemonic,
    372
            string calldata derivationPath,
    373
            string calldata language,
    374
            uint32 count
    375
        ) external returns (address[] memory keyAddrs);
    376
    
                                                    
                                                
    377
        /// Signs data with a `Wallet`.
    378
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    379
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    380
        /// This format reduces the signature size from 65 to 64 bytes.
    381
        function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);
    382
    
                                                    
                                                
    383
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    384
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    385
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    386
        /// This format reduces the signature size from 65 to 64 bytes.
    387
        function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    388
    
                                                    
                                                
    389
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    390
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    391
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    392
        /// This format reduces the signature size from 65 to 64 bytes.
    393
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    394
        /// if exactly one signer is provided to the script, that signer is used.
    395
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    396
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    397
        function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    398
    
                                                    
                                                
    399
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    400
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    401
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    402
        /// This format reduces the signature size from 65 to 64 bytes.
    403
        /// Raises error if none of the signers passed into the script have provided address.
    404
        function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    405
    
                                                    
                                                
    406
        /// Signs `digest` with `privateKey` using the secp256r1 curve.
    407
        function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);
    408
    
                                                    
                                                
    409
        /// Signs data with a `Wallet`.
    410
        function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
    411
    
                                                    
                                                
    412
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    413
        function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    414
    
                                                    
                                                
    415
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    416
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    417
        /// if exactly one signer is provided to the script, that signer is used.
    418
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    419
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    420
        function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    421
    
                                                    
                                                
    422
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    423
        /// Raises error if none of the signers passed into the script have provided address.
    424
        function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    425
    
                                                    
                                                
    426
        // ======== Environment ========
    427
    
                                                    
                                                
    428
        /// Gets the environment variable `name` and parses it as `address`.
    429
        /// Reverts if the variable was not found or could not be parsed.
    430
        function envAddress(string calldata name) external view returns (address value);
    431
    
                                                    
                                                
    432
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    433
        /// Reverts if the variable was not found or could not be parsed.
    434
        function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);
    435
    
                                                    
                                                
    436
        /// Gets the environment variable `name` and parses it as `bool`.
    437
        /// Reverts if the variable was not found or could not be parsed.
    438
        function envBool(string calldata name) external view returns (bool value);
    439
    
                                                    
                                                
    440
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    441
        /// Reverts if the variable was not found or could not be parsed.
    442
        function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);
    443
    
                                                    
                                                
    444
        /// Gets the environment variable `name` and parses it as `bytes32`.
    445
        /// Reverts if the variable was not found or could not be parsed.
    446
        function envBytes32(string calldata name) external view returns (bytes32 value);
    447
    
                                                    
                                                
    448
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    449
        /// Reverts if the variable was not found or could not be parsed.
    450
        function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);
    451
    
                                                    
                                                
    452
        /// Gets the environment variable `name` and parses it as `bytes`.
    453
        /// Reverts if the variable was not found or could not be parsed.
    454
        function envBytes(string calldata name) external view returns (bytes memory value);
    455
    
                                                    
                                                
    456
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    457
        /// Reverts if the variable was not found or could not be parsed.
    458
        function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);
    459
    
                                                    
                                                
    460
        /// Gets the environment variable `name` and returns true if it exists, else returns false.
    461
        function envExists(string calldata name) external view returns (bool result);
    462
    
                                                    
                                                
    463
        /// Gets the environment variable `name` and parses it as `int256`.
    464
        /// Reverts if the variable was not found or could not be parsed.
    465
        function envInt(string calldata name) external view returns (int256 value);
    466
    
                                                    
                                                
    467
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    468
        /// Reverts if the variable was not found or could not be parsed.
    469
        function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);
    470
    
                                                    
                                                
    471
        /// Gets the environment variable `name` and parses it as `bool`.
    472
        /// Reverts if the variable could not be parsed.
    473
        /// Returns `defaultValue` if the variable was not found.
    474
        function envOr(string calldata name, bool defaultValue) external view returns (bool value);
    475
    
                                                    
                                                
    476
        /// Gets the environment variable `name` and parses it as `uint256`.
    477
        /// Reverts if the variable could not be parsed.
    478
        /// Returns `defaultValue` if the variable was not found.
    479
        function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);
    480
    
                                                    
                                                
    481
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    482
        /// Reverts if the variable could not be parsed.
    483
        /// Returns `defaultValue` if the variable was not found.
    484
        function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
    485
            external
    486
            view
    487
            returns (address[] memory value);
    488
    
                                                    
                                                
    489
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    490
        /// Reverts if the variable could not be parsed.
    491
        /// Returns `defaultValue` if the variable was not found.
    492
        function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
    493
            external
    494
            view
    495
            returns (bytes32[] memory value);
    496
    
                                                    
                                                
    497
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    498
        /// Reverts if the variable could not be parsed.
    499
        /// Returns `defaultValue` if the variable was not found.
    500
        function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
    501
            external
    502
            view
    503
            returns (string[] memory value);
    504
    
                                                    
                                                
    505
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    506
        /// Reverts if the variable could not be parsed.
    507
        /// Returns `defaultValue` if the variable was not found.
    508
        function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
    509
            external
    510
            view
    511
            returns (bytes[] memory value);
    512
    
                                                    
                                                
    513
        /// Gets the environment variable `name` and parses it as `int256`.
    514
        /// Reverts if the variable could not be parsed.
    515
        /// Returns `defaultValue` if the variable was not found.
    516
        function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);
    517
    
                                                    
                                                
    518
        /// Gets the environment variable `name` and parses it as `address`.
    519
        /// Reverts if the variable could not be parsed.
    520
        /// Returns `defaultValue` if the variable was not found.
    521
        function envOr(string calldata name, address defaultValue) external view returns (address value);
    522
    
                                                    
                                                
    523
        /// Gets the environment variable `name` and parses it as `bytes32`.
    524
        /// Reverts if the variable could not be parsed.
    525
        /// Returns `defaultValue` if the variable was not found.
    526
        function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);
    527
    
                                                    
                                                
    528
        /// Gets the environment variable `name` and parses it as `string`.
    529
        /// Reverts if the variable could not be parsed.
    530
        /// Returns `defaultValue` if the variable was not found.
    531
        function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);
    532
    
                                                    
                                                
    533
        /// Gets the environment variable `name` and parses it as `bytes`.
    534
        /// Reverts if the variable could not be parsed.
    535
        /// Returns `defaultValue` if the variable was not found.
    536
        function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);
    537
    
                                                    
                                                
    538
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    539
        /// Reverts if the variable could not be parsed.
    540
        /// Returns `defaultValue` if the variable was not found.
    541
        function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
    542
            external
    543
            view
    544
            returns (bool[] memory value);
    545
    
                                                    
                                                
    546
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    547
        /// Reverts if the variable could not be parsed.
    548
        /// Returns `defaultValue` if the variable was not found.
    549
        function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
    550
            external
    551
            view
    552
            returns (uint256[] memory value);
    553
    
                                                    
                                                
    554
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    555
        /// Reverts if the variable could not be parsed.
    556
        /// Returns `defaultValue` if the variable was not found.
    557
        function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
    558
            external
    559
            view
    560
            returns (int256[] memory value);
    561
    
                                                    
                                                
    562
        /// Gets the environment variable `name` and parses it as `string`.
    563
        /// Reverts if the variable was not found or could not be parsed.
    564
        function envString(string calldata name) external view returns (string memory value);
    565
    
                                                    
                                                
    566
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    567
        /// Reverts if the variable was not found or could not be parsed.
    568
        function envString(string calldata name, string calldata delim) external view returns (string[] memory value);
    569
    
                                                    
                                                
    570
        /// Gets the environment variable `name` and parses it as `uint256`.
    571
        /// Reverts if the variable was not found or could not be parsed.
    572
        function envUint(string calldata name) external view returns (uint256 value);
    573
    
                                                    
                                                
    574
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    575
        /// Reverts if the variable was not found or could not be parsed.
    576
        function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);
    577
    
                                                    
                                                
    578
        /// Returns true if `forge` command was executed in given context.
    579
        function isContext(ForgeContext context) external view returns (bool result);
    580
    
                                                    
                                                
    581
        /// Sets environment variables.
    582
        function setEnv(string calldata name, string calldata value) external;
    583
    
                                                    
                                                
    584
        // ======== EVM ========
    585
    
                                                    
                                                
    586
        /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.
    587
        function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);
    588
    
                                                    
                                                
    589
        /// Gets the address for a given private key.
    590
        function addr(uint256 privateKey) external pure returns (address keyAddr);
    591
    
                                                    
                                                
    592
        /// Gets all the logs according to specified filter.
    593
        function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
    594
            external
    595
            returns (EthGetLogs[] memory logs);
    596
    
                                                    
                                                
    597
        /// Gets the current `block.blobbasefee`.
    598
        /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,
    599
        /// and as a result will get optimized out by the compiler.
    600
        /// See https://github.com/foundry-rs/foundry/issues/6180
    601
        function getBlobBaseFee() external view returns (uint256 blobBaseFee);
    602
    
                                                    
                                                
    603
        /// Gets the current `block.number`.
    604
        /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,
    605
        /// and as a result will get optimized out by the compiler.
    606
        /// See https://github.com/foundry-rs/foundry/issues/6180
    607
        function getBlockNumber() external view returns (uint256 height);
    608
    
                                                    
                                                
    609
        /// Gets the current `block.timestamp`.
    610
        /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,
    611
        /// and as a result will get optimized out by the compiler.
    612
        /// See https://github.com/foundry-rs/foundry/issues/6180
    613
        function getBlockTimestamp() external view returns (uint256 timestamp);
    614
    
                                                    
                                                
    615
        /// Gets the map key and parent of a mapping at a given slot, for a given address.
    616
        function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
    617
            external
    618
            returns (bool found, bytes32 key, bytes32 parent);
    619
    
                                                    
                                                
    620
        /// Gets the number of elements in the mapping at the given slot, for a given address.
    621
        function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);
    622
    
                                                    
                                                
    623
        /// Gets the elements at index idx of the mapping at the given slot, for a given address. The
    624
        /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).
    625
        function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);
    626
    
                                                    
                                                
    627
        /// Gets the nonce of an account.
    628
        function getNonce(address account) external view returns (uint64 nonce);
    629
    
                                                    
                                                
    630
        /// Get the nonce of a `Wallet`.
    631
        function getNonce(Wallet calldata wallet) external returns (uint64 nonce);
    632
    
                                                    
                                                
    633
        /// Gets all the recorded logs.
    634
        function getRecordedLogs() external returns (Log[] memory logs);
    635
    
                                                    
                                                
    636
        /// Returns state diffs from current `vm.startStateDiffRecording` session.
    637
        function getStateDiff() external view returns (string memory diff);
    638
    
                                                    
                                                
    639
        /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.
    640
        function getStateDiffJson() external view returns (string memory diff);
    641
    
                                                    
                                                
    642
        /// Gets the gas used in the last call from the callee perspective.
    643
        function lastCallGas() external view returns (Gas memory gas);
    644
    
                                                    
                                                
    645
        /// Loads a storage slot from an address.
    646
        function load(address target, bytes32 slot) external view returns (bytes32 data);
    647
    
                                                    
                                                
    648
        /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.
    649
        function pauseGasMetering() external;
    650
    
                                                    
                                                
    651
        /// Records all storage reads and writes.
    652
        function record() external;
    653
    
                                                    
                                                
    654
        /// Record all the transaction logs.
    655
        function recordLogs() external;
    656
    
                                                    
                                                
    657
        /// Reset gas metering (i.e. gas usage is set to gas limit).
    658
        function resetGasMetering() external;
    659
    
                                                    
                                                
    660
        /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.
    661
        function resumeGasMetering() external;
    662
    
                                                    
                                                
    663
        /// Performs an Ethereum JSON-RPC request to the current fork URL.
    664
        function rpc(string calldata method, string calldata params) external returns (bytes memory data);
    665
    
                                                    
                                                
    666
        /// Performs an Ethereum JSON-RPC request to the given endpoint.
    667
        function rpc(string calldata urlOrAlias, string calldata method, string calldata params)
    668
            external
    669
            returns (bytes memory data);
    670
    
                                                    
                                                
    671
        /// Records the debug trace during the run.
    672
        function startDebugTraceRecording() external;
    673
    
                                                    
                                                
    674
        /// Starts recording all map SSTOREs for later retrieval.
    675
        function startMappingRecording() external;
    676
    
                                                    
                                                
    677
        /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,
    678
        /// along with the context of the calls
    679
        function startStateDiffRecording() external;
    680
    
                                                    
                                                
    681
        /// Stop debug trace recording and returns the recorded debug trace.
    682
        function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);
    683
    
                                                    
                                                
    684
        /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.
    685
        function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);
    686
    
                                                    
                                                
    687
        /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.
    688
        function stopMappingRecording() external;
    689
    
                                                    
                                                
    690
        // ======== Filesystem ========
    691
    
                                                    
                                                
    692
        /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
    693
        /// `path` is relative to the project root.
    694
        function closeFile(string calldata path) external;
    695
    
                                                    
                                                
    696
        /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.
    697
        /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.
    698
        /// Both `from` and `to` are relative to the project root.
    699
        function copyFile(string calldata from, string calldata to) external returns (uint64 copied);
    700
    
                                                    
                                                
    701
        /// Creates a new, empty directory at the provided path.
    702
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    703
        /// - User lacks permissions to modify `path`.
    704
        /// - A parent of the given path doesn't exist and `recursive` is false.
    705
        /// - `path` already exists and `recursive` is false.
    706
        /// `path` is relative to the project root.
    707
        function createDir(string calldata path, bool recursive) external;
    708
    
                                                    
                                                
    709
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    710
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    711
        function deployCode(string calldata artifactPath) external returns (address deployedAddress);
    712
    
                                                    
                                                
    713
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    714
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    715
        /// Additionally accepts abi-encoded constructor arguments.
    716
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs)
    717
            external
    718
            returns (address deployedAddress);
    719
    
                                                    
                                                
    720
        /// Returns true if the given path points to an existing entity, else returns false.
    721
        function exists(string calldata path) external view returns (bool result);
    722
    
                                                    
                                                
    723
        /// Performs a foreign function call via the terminal.
    724
        function ffi(string[] calldata commandInput) external returns (bytes memory result);
    725
    
                                                    
                                                
    726
        /// Given a path, query the file system to get information about a file, directory, etc.
    727
        function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);
    728
    
                                                    
                                                
    729
        /// Gets the artifact path from code (aka. creation code).
    730
        function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);
    731
    
                                                    
                                                
    732
        /// Gets the artifact path from deployed code (aka. runtime code).
    733
        function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);
    734
    
                                                    
                                                
    735
        /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.
    736
        /// For example:
    737
        /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.
    738
        /// The most recent call can be fetched by passing `txType` as `CALL`.
    739
        function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    740
            external
    741
            view
    742
            returns (BroadcastTxSummary memory);
    743
    
                                                    
                                                
    744
        /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.
    745
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    746
        function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    747
            external
    748
            view
    749
            returns (BroadcastTxSummary[] memory);
    750
    
                                                    
                                                
    751
        /// Returns all broadcasts for the given contract on `chainId`.
    752
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    753
        function getBroadcasts(string calldata contractName, uint64 chainId)
    754
            external
    755
            view
    756
            returns (BroadcastTxSummary[] memory);
    757
    
                                                    
                                                
    758
        /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    759
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    760
        function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);
    761
    
                                                    
                                                
    762
        /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    763
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    764
        function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);
    765
    
                                                    
                                                
    766
        /// Returns the most recent deployment for the current `chainId`.
    767
        function getDeployment(string calldata contractName) external view returns (address deployedAddress);
    768
    
                                                    
                                                
    769
        /// Returns the most recent deployment for the given contract on `chainId`
    770
        function getDeployment(string calldata contractName, uint64 chainId)
    771
            external
    772
            view
    773
            returns (address deployedAddress);
    774
    
                                                    
                                                
    775
        /// Returns all deployments for the given contract on `chainId`
    776
        /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.
    777
        /// The most recent deployment is the first element, and the oldest is the last.
    778
        function getDeployments(string calldata contractName, uint64 chainId)
    779
            external
    780
            view
    781
            returns (address[] memory deployedAddresses);
    782
    
                                                    
                                                
    783
        /// Returns true if the path exists on disk and is pointing at a directory, else returns false.
    784
        function isDir(string calldata path) external view returns (bool result);
    785
    
                                                    
                                                
    786
        /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.
    787
        function isFile(string calldata path) external view returns (bool result);
    788
    
                                                    
                                                
    789
        /// Get the path of the current project root.
    790
        function projectRoot() external view returns (string memory path);
    791
    
                                                    
                                                
    792
        /// Prompts the user for a string value in the terminal.
    793
        function prompt(string calldata promptText) external returns (string memory input);
    794
    
                                                    
                                                
    795
        /// Prompts the user for an address in the terminal.
    796
        function promptAddress(string calldata promptText) external returns (address);
    797
    
                                                    
                                                
    798
        /// Prompts the user for a hidden string value in the terminal.
    799
        function promptSecret(string calldata promptText) external returns (string memory input);
    800
    
                                                    
                                                
    801
        /// Prompts the user for hidden uint256 in the terminal (usually pk).
    802
        function promptSecretUint(string calldata promptText) external returns (uint256);
    803
    
                                                    
                                                
    804
        /// Prompts the user for uint256 in the terminal.
    805
        function promptUint(string calldata promptText) external returns (uint256);
    806
    
                                                    
                                                
    807
        /// Reads the directory at the given path recursively, up to `maxDepth`.
    808
        /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.
    809
        /// Follows symbolic links if `followLinks` is true.
    810
        function readDir(string calldata path) external view returns (DirEntry[] memory entries);
    811
    
                                                    
                                                
    812
        /// See `readDir(string)`.
    813
        function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);
    814
    
                                                    
                                                
    815
        /// See `readDir(string)`.
    816
        function readDir(string calldata path, uint64 maxDepth, bool followLinks)
    817
            external
    818
            view
    819
            returns (DirEntry[] memory entries);
    820
    
                                                    
                                                
    821
        /// Reads the entire content of file to string. `path` is relative to the project root.
    822
        function readFile(string calldata path) external view returns (string memory data);
    823
    
                                                    
                                                
    824
        /// Reads the entire content of file as binary. `path` is relative to the project root.
    825
        function readFileBinary(string calldata path) external view returns (bytes memory data);
    826
    
                                                    
                                                
    827
        /// Reads next line of file to string.
    828
        function readLine(string calldata path) external view returns (string memory line);
    829
    
                                                    
                                                
    830
        /// Reads a symbolic link, returning the path that the link points to.
    831
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    832
        /// - `path` is not a symbolic link.
    833
        /// - `path` does not exist.
    834
        function readLink(string calldata linkPath) external view returns (string memory targetPath);
    835
    
                                                    
                                                
    836
        /// Removes a directory at the provided path.
    837
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    838
        /// - `path` doesn't exist.
    839
        /// - `path` isn't a directory.
    840
        /// - User lacks permissions to modify `path`.
    841
        /// - The directory is not empty and `recursive` is false.
    842
        /// `path` is relative to the project root.
    843
        function removeDir(string calldata path, bool recursive) external;
    844
    
                                                    
                                                
    845
        /// Removes a file from the filesystem.
    846
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    847
        /// - `path` points to a directory.
    848
        /// - The file doesn't exist.
    849
        /// - The user lacks permissions to remove the file.
    850
        /// `path` is relative to the project root.
    851
        function removeFile(string calldata path) external;
    852
    
                                                    
                                                
    853
        /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.
    854
        function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);
    855
    
                                                    
                                                
    856
        /// Returns the time since unix epoch in milliseconds.
    857
        function unixTime() external view returns (uint256 milliseconds);
    858
    
                                                    
                                                
    859
        /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
    860
        /// `path` is relative to the project root.
    861
        function writeFile(string calldata path, string calldata data) external;
    862
    
                                                    
                                                
    863
        /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.
    864
        /// `path` is relative to the project root.
    865
        function writeFileBinary(string calldata path, bytes calldata data) external;
    866
    
                                                    
                                                
    867
        /// Writes line to file, creating a file if it does not exist.
    868
        /// `path` is relative to the project root.
    869
        function writeLine(string calldata path, string calldata data) external;
    870
    
                                                    
                                                
    871
        // ======== JSON ========
    872
    
                                                    
                                                
    873
        /// Checks if `key` exists in a JSON object.
    874
        function keyExistsJson(string calldata json, string calldata key) external view returns (bool);
    875
    
                                                    
                                                
    876
        /// Parses a string of JSON data at `key` and coerces it to `address`.
    877
        function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);
    878
    
                                                    
                                                
    879
        /// Parses a string of JSON data at `key` and coerces it to `address[]`.
    880
        function parseJsonAddressArray(string calldata json, string calldata key)
    881
            external
    882
            pure
    883
            returns (address[] memory);
    884
    
                                                    
                                                
    885
        /// Parses a string of JSON data at `key` and coerces it to `bool`.
    886
        function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);
    887
    
                                                    
                                                
    888
        /// Parses a string of JSON data at `key` and coerces it to `bool[]`.
    889
        function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);
    890
    
                                                    
                                                
    891
        /// Parses a string of JSON data at `key` and coerces it to `bytes`.
    892
        function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);
    893
    
                                                    
                                                
    894
        /// Parses a string of JSON data at `key` and coerces it to `bytes32`.
    895
        function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);
    896
    
                                                    
                                                
    897
        /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.
    898
        function parseJsonBytes32Array(string calldata json, string calldata key)
    899
            external
    900
            pure
    901
            returns (bytes32[] memory);
    902
    
                                                    
                                                
    903
        /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.
    904
        function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);
    905
    
                                                    
                                                
    906
        /// Parses a string of JSON data at `key` and coerces it to `int256`.
    907
        function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);
    908
    
                                                    
                                                
    909
        /// Parses a string of JSON data at `key` and coerces it to `int256[]`.
    910
        function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);
    911
    
                                                    
                                                
    912
        /// Returns an array of all the keys in a JSON object.
    913
        function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);
    914
    
                                                    
                                                
    915
        /// Parses a string of JSON data at `key` and coerces it to `string`.
    916
        function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);
    917
    
                                                    
                                                
    918
        /// Parses a string of JSON data at `key` and coerces it to `string[]`.
    919
        function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);
    920
    
                                                    
                                                
    921
        /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.
    922
        function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
    923
            external
    924
            pure
    925
            returns (bytes memory);
    926
    
                                                    
                                                
    927
        /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.
    928
        function parseJsonType(string calldata json, string calldata typeDescription)
    929
            external
    930
            pure
    931
            returns (bytes memory);
    932
    
                                                    
                                                
    933
        /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.
    934
        function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)
    935
            external
    936
            pure
    937
            returns (bytes memory);
    938
    
                                                    
                                                
    939
        /// Parses a string of JSON data at `key` and coerces it to `uint256`.
    940
        function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);
    941
    
                                                    
                                                
    942
        /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.
    943
        function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);
    944
    
                                                    
                                                
    945
        /// ABI-encodes a JSON object.
    946
        function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);
    947
    
                                                    
                                                
    948
        /// ABI-encodes a JSON object at `key`.
    949
        function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);
    950
    
                                                    
                                                
    951
        /// See `serializeJson`.
    952
        function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
    953
            external
    954
            returns (string memory json);
    955
    
                                                    
                                                
    956
        /// See `serializeJson`.
    957
        function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
    958
            external
    959
            returns (string memory json);
    960
    
                                                    
                                                
    961
        /// See `serializeJson`.
    962
        function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
    963
            external
    964
            returns (string memory json);
    965
    
                                                    
                                                
    966
        /// See `serializeJson`.
    967
        function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
    968
            external
    969
            returns (string memory json);
    970
    
                                                    
                                                
    971
        /// See `serializeJson`.
    972
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
    973
            external
    974
            returns (string memory json);
    975
    
                                                    
                                                
    976
        /// See `serializeJson`.
    977
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
    978
            external
    979
            returns (string memory json);
    980
    
                                                    
                                                
    981
        /// See `serializeJson`.
    982
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
    983
            external
    984
            returns (string memory json);
    985
    
                                                    
                                                
    986
        /// See `serializeJson`.
    987
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
    988
            external
    989
            returns (string memory json);
    990
    
                                                    
                                                
    991
        /// See `serializeJson`.
    992
        function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
    993
            external
    994
            returns (string memory json);
    995
    
                                                    
                                                
    996
        /// See `serializeJson`.
    997
        function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
    998
            external
    999
            returns (string memory json);
    1000
    
                                                    
                                                
    1001
        /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.
    1002
        /// Returns the stringified version of the specific JSON file up to that moment.
    1003
        function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);
    1004
    
                                                    
                                                
    1005
        /// See `serializeJson`.
    1006
        function serializeJsonType(string calldata typeDescription, bytes calldata value)
    1007
            external
    1008
            pure
    1009
            returns (string memory json);
    1010
    
                                                    
                                                
    1011
        /// See `serializeJson`.
    1012
        function serializeJsonType(
    1013
            string calldata objectKey,
    1014
            string calldata valueKey,
    1015
            string calldata typeDescription,
    1016
            bytes calldata value
    1017
        ) external returns (string memory json);
    1018
    
                                                    
                                                
    1019
        /// See `serializeJson`.
    1020
        function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
    1021
            external
    1022
            returns (string memory json);
    1023
    
                                                    
                                                
    1024
        /// See `serializeJson`.
    1025
        function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
    1026
            external
    1027
            returns (string memory json);
    1028
    
                                                    
                                                
    1029
        /// See `serializeJson`.
    1030
        function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)
    1031
            external
    1032
            returns (string memory json);
    1033
    
                                                    
                                                
    1034
        /// See `serializeJson`.
    1035
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
    1036
            external
    1037
            returns (string memory json);
    1038
    
                                                    
                                                
    1039
        /// See `serializeJson`.
    1040
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
    1041
            external
    1042
            returns (string memory json);
    1043
    
                                                    
                                                
    1044
        /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
    1045
        function writeJson(string calldata json, string calldata path) external;
    1046
    
                                                    
                                                
    1047
        /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.>
    1048
        /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.
    1049
        function writeJson(string calldata json, string calldata path, string calldata valueKey) external;
    1050
    
                                                    
                                                
    1051
        /// Checks if `key` exists in a JSON object
    1052
        /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.
    1053
        function keyExists(string calldata json, string calldata key) external view returns (bool);
    1054
    
                                                    
                                                
    1055
        // ======== Scripting ========
    1056
    
                                                    
                                                
    1057
        /// Designate the next call as an EIP-7702 transaction
    1058
        function attachDelegation(SignedDelegation calldata signedDelegation) external;
    1059
    
                                                    
                                                
    1060
        /// Takes a signed transaction and broadcasts it to the network.
    1061
        function broadcastRawTransaction(bytes calldata data) external;
    1062
    
                                                    
                                                
    1063
        /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.
    1064
        /// Broadcasting address is determined by checking the following in order:
    1065
        /// 1. If `--sender` argument was provided, that address is used.
    1066
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1067
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1068
        function broadcast() external;
    1069
    
                                                    
                                                
    1070
        /// Has the next call (at this call depth only) create a transaction with the address provided
    1071
        /// as the sender that can later be signed and sent onchain.
    1072
        function broadcast(address signer) external;
    1073
    
                                                    
                                                
    1074
        /// Has the next call (at this call depth only) create a transaction with the private key
    1075
        /// provided as the sender that can later be signed and sent onchain.
    1076
        function broadcast(uint256 privateKey) external;
    1077
    
                                                    
                                                
    1078
        /// Returns addresses of available unlocked wallets in the script environment.
    1079
        function getWallets() external returns (address[] memory wallets);
    1080
    
                                                    
                                                
    1081
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction
    1082
        function signAndAttachDelegation(address implementation, uint256 privateKey)
    1083
            external
    1084
            returns (SignedDelegation memory signedDelegation);
    1085
    
                                                    
                                                
    1086
        /// Sign an EIP-7702 authorization for delegation
    1087
        function signDelegation(address implementation, uint256 privateKey)
    1088
            external
    1089
            returns (SignedDelegation memory signedDelegation);
    1090
    
                                                    
                                                
    1091
        /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.
    1092
        /// Broadcasting address is determined by checking the following in order:
    1093
        /// 1. If `--sender` argument was provided, that address is used.
    1094
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1095
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1096
        function startBroadcast() external;
    1097
    
                                                    
                                                
    1098
        /// Has all subsequent calls (at this call depth only) create transactions with the address
    1099
        /// provided that can later be signed and sent onchain.
    1100
        function startBroadcast(address signer) external;
    1101
    
                                                    
                                                
    1102
        /// Has all subsequent calls (at this call depth only) create transactions with the private key
    1103
        /// provided that can later be signed and sent onchain.
    1104
        function startBroadcast(uint256 privateKey) external;
    1105
    
                                                    
                                                
    1106
        /// Stops collecting onchain transactions.
    1107
        function stopBroadcast() external;
    1108
    
                                                    
                                                
    1109
        // ======== String ========
    1110
    
                                                    
                                                
    1111
        /// Returns true if `search` is found in `subject`, false otherwise.
    1112
        function contains(string calldata subject, string calldata search) external returns (bool result);
    1113
    
                                                    
                                                
    1114
        /// Returns the index of the first occurrence of a `key` in an `input` string.
    1115
        /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.
    1116
        /// Returns 0 in case of an empty `key`.
    1117
        function indexOf(string calldata input, string calldata key) external pure returns (uint256);
    1118
    
                                                    
                                                
    1119
        /// Parses the given `string` into an `address`.
    1120
        function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);
    1121
    
                                                    
                                                
    1122
        /// Parses the given `string` into a `bool`.
    1123
        function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
    1124
    
                                                    
                                                
    1125
        /// Parses the given `string` into `bytes`.
    1126
        function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);
    1127
    
                                                    
                                                
    1128
        /// Parses the given `string` into a `bytes32`.
    1129
        function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);
    1130
    
                                                    
                                                
    1131
        /// Parses the given `string` into a `int256`.
    1132
        function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);
    1133
    
                                                    
                                                
    1134
        /// Parses the given `string` into a `uint256`.
    1135
        function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);
    1136
    
                                                    
                                                
    1137
        /// Replaces occurrences of `from` in the given `string` with `to`.
    1138
        function replace(string calldata input, string calldata from, string calldata to)
    1139
            external
    1140
            pure
    1141
            returns (string memory output);
    1142
    
                                                    
                                                
    1143
        /// Splits the given `string` into an array of strings divided by the `delimiter`.
    1144
        function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);
    1145
    
                                                    
                                                
    1146
        /// Converts the given `string` value to Lowercase.
    1147
        function toLowercase(string calldata input) external pure returns (string memory output);
    1148
    
                                                    
                                                
    1149
        /// Converts the given value to a `string`.
    1150
        function toString(address value) external pure returns (string memory stringifiedValue);
    1151
    
                                                    
                                                
    1152
        /// Converts the given value to a `string`.
    1153
        function toString(bytes calldata value) external pure returns (string memory stringifiedValue);
    1154
    
                                                    
                                                
    1155
        /// Converts the given value to a `string`.
    1156
        function toString(bytes32 value) external pure returns (string memory stringifiedValue);
    1157
    
                                                    
                                                
    1158
        /// Converts the given value to a `string`.
    1159
        function toString(bool value) external pure returns (string memory stringifiedValue);
    1160
    
                                                    
                                                
    1161
        /// Converts the given value to a `string`.
    1162
        function toString(uint256 value) external pure returns (string memory stringifiedValue);
    1163
    
                                                    
                                                
    1164
        /// Converts the given value to a `string`.
    1165
        function toString(int256 value) external pure returns (string memory stringifiedValue);
    1166
    
                                                    
                                                
    1167
        /// Converts the given `string` value to Uppercase.
    1168
        function toUppercase(string calldata input) external pure returns (string memory output);
    1169
    
                                                    
                                                
    1170
        /// Trims leading and trailing whitespace from the given `string` value.
    1171
        function trim(string calldata input) external pure returns (string memory output);
    1172
    
                                                    
                                                
    1173
        // ======== Testing ========
    1174
    
                                                    
                                                
    1175
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1176
        /// Formats values with decimals in failure message.
    1177
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;
    1178
    
                                                    
                                                
    1179
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1180
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1181
        function assertApproxEqAbsDecimal(
    1182
            uint256 left,
    1183
            uint256 right,
    1184
            uint256 maxDelta,
    1185
            uint256 decimals,
    1186
            string calldata error
    1187
        ) external pure;
    1188
    
                                                    
                                                
    1189
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1190
        /// Formats values with decimals in failure message.
    1191
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;
    1192
    
                                                    
                                                
    1193
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1194
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1195
        function assertApproxEqAbsDecimal(
    1196
            int256 left,
    1197
            int256 right,
    1198
            uint256 maxDelta,
    1199
            uint256 decimals,
    1200
            string calldata error
    1201
        ) external pure;
    1202
    
                                                    
                                                
    1203
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1204
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;
    1205
    
                                                    
                                                
    1206
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1207
        /// Includes error message into revert string on failure.
    1208
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;
    1209
    
                                                    
                                                
    1210
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1211
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;
    1212
    
                                                    
                                                
    1213
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1214
        /// Includes error message into revert string on failure.
    1215
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;
    1216
    
                                                    
                                                
    1217
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1218
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1219
        /// Formats values with decimals in failure message.
    1220
        function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
    1221
            external
    1222
            pure;
    1223
    
                                                    
                                                
    1224
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1225
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1226
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1227
        function assertApproxEqRelDecimal(
    1228
            uint256 left,
    1229
            uint256 right,
    1230
            uint256 maxPercentDelta,
    1231
            uint256 decimals,
    1232
            string calldata error
    1233
        ) external pure;
    1234
    
                                                    
                                                
    1235
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1236
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1237
        /// Formats values with decimals in failure message.
    1238
        function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)
    1239
            external
    1240
            pure;
    1241
    
                                                    
                                                
    1242
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1243
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1244
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1245
        function assertApproxEqRelDecimal(
    1246
            int256 left,
    1247
            int256 right,
    1248
            uint256 maxPercentDelta,
    1249
            uint256 decimals,
    1250
            string calldata error
    1251
        ) external pure;
    1252
    
                                                    
                                                
    1253
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1254
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1255
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;
    1256
    
                                                    
                                                
    1257
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1258
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1259
        /// Includes error message into revert string on failure.
    1260
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)
    1261
            external
    1262
            pure;
    1263
    
                                                    
                                                
    1264
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1265
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1266
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;
    1267
    
                                                    
                                                
    1268
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1269
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1270
        /// Includes error message into revert string on failure.
    1271
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)
    1272
            external
    1273
            pure;
    1274
    
                                                    
                                                
    1275
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1276
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1277
    
                                                    
                                                
    1278
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1279
        /// Includes error message into revert string on failure.
    1280
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1281
    
                                                    
                                                
    1282
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1283
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1284
    
                                                    
                                                
    1285
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1286
        /// Includes error message into revert string on failure.
    1287
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1288
    
                                                    
                                                
    1289
        /// Asserts that two `bool` values are equal.
    1290
        function assertEq(bool left, bool right) external pure;
    1291
    
                                                    
                                                
    1292
        /// Asserts that two `bool` values are equal and includes error message into revert string on failure.
    1293
        function assertEq(bool left, bool right, string calldata error) external pure;
    1294
    
                                                    
                                                
    1295
        /// Asserts that two `string` values are equal.
    1296
        function assertEq(string calldata left, string calldata right) external pure;
    1297
    
                                                    
                                                
    1298
        /// Asserts that two `string` values are equal and includes error message into revert string on failure.
    1299
        function assertEq(string calldata left, string calldata right, string calldata error) external pure;
    1300
    
                                                    
                                                
    1301
        /// Asserts that two `bytes` values are equal.
    1302
        function assertEq(bytes calldata left, bytes calldata right) external pure;
    1303
    
                                                    
                                                
    1304
        /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.
    1305
        function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1306
    
                                                    
                                                
    1307
        /// Asserts that two arrays of `bool` values are equal.
    1308
        function assertEq(bool[] calldata left, bool[] calldata right) external pure;
    1309
    
                                                    
                                                
    1310
        /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.
    1311
        function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1312
    
                                                    
                                                
    1313
        /// Asserts that two arrays of `uint256 values are equal.
    1314
        function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1315
    
                                                    
                                                
    1316
        /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.
    1317
        function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1318
    
                                                    
                                                
    1319
        /// Asserts that two arrays of `int256` values are equal.
    1320
        function assertEq(int256[] calldata left, int256[] calldata right) external pure;
    1321
    
                                                    
                                                
    1322
        /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.
    1323
        function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1324
    
                                                    
                                                
    1325
        /// Asserts that two `uint256` values are equal.
    1326
        function assertEq(uint256 left, uint256 right) external pure;
    1327
    
                                                    
                                                
    1328
        /// Asserts that two arrays of `address` values are equal.
    1329
        function assertEq(address[] calldata left, address[] calldata right) external pure;
    1330
    
                                                    
                                                
    1331
        /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.
    1332
        function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1333
    
                                                    
                                                
    1334
        /// Asserts that two arrays of `bytes32` values are equal.
    1335
        function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1336
    
                                                    
                                                
    1337
        /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.
    1338
        function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1339
    
                                                    
                                                
    1340
        /// Asserts that two arrays of `string` values are equal.
    1341
        function assertEq(string[] calldata left, string[] calldata right) external pure;
    1342
    
                                                    
                                                
    1343
        /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.
    1344
        function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1345
    
                                                    
                                                
    1346
        /// Asserts that two arrays of `bytes` values are equal.
    1347
        function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1348
    
                                                    
                                                
    1349
        /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.
    1350
        function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1351
    
                                                    
                                                
    1352
        /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.
    1353
        function assertEq(uint256 left, uint256 right, string calldata error) external pure;
    1354
    
                                                    
                                                
    1355
        /// Asserts that two `int256` values are equal.
    1356
        function assertEq(int256 left, int256 right) external pure;
    1357
    
                                                    
                                                
    1358
        /// Asserts that two `int256` values are equal and includes error message into revert string on failure.
    1359
        function assertEq(int256 left, int256 right, string calldata error) external pure;
    1360
    
                                                    
                                                
    1361
        /// Asserts that two `address` values are equal.
    1362
        function assertEq(address left, address right) external pure;
    1363
    
                                                    
                                                
    1364
        /// Asserts that two `address` values are equal and includes error message into revert string on failure.
    1365
        function assertEq(address left, address right, string calldata error) external pure;
    1366
    
                                                    
                                                
    1367
        /// Asserts that two `bytes32` values are equal.
    1368
        function assertEq(bytes32 left, bytes32 right) external pure;
    1369
    
                                                    
                                                
    1370
        /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.
    1371
        function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1372
    
                                                    
                                                
    1373
        /// Asserts that the given condition is false.
    1374
        function assertFalse(bool condition) external pure;
    1375
    
                                                    
                                                
    1376
        /// Asserts that the given condition is false and includes error message into revert string on failure.
    1377
        function assertFalse(bool condition, string calldata error) external pure;
    1378
    
                                                    
                                                
    1379
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1380
        /// Formats values with decimals in failure message.
    1381
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1382
    
                                                    
                                                
    1383
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1384
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1385
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1386
    
                                                    
                                                
    1387
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1388
        /// Formats values with decimals in failure message.
    1389
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1390
    
                                                    
                                                
    1391
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1392
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1393
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1394
    
                                                    
                                                
    1395
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1396
        function assertGe(uint256 left, uint256 right) external pure;
    1397
    
                                                    
                                                
    1398
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1399
        /// Includes error message into revert string on failure.
    1400
        function assertGe(uint256 left, uint256 right, string calldata error) external pure;
    1401
    
                                                    
                                                
    1402
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1403
        function assertGe(int256 left, int256 right) external pure;
    1404
    
                                                    
                                                
    1405
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1406
        /// Includes error message into revert string on failure.
    1407
        function assertGe(int256 left, int256 right, string calldata error) external pure;
    1408
    
                                                    
                                                
    1409
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1410
        /// Formats values with decimals in failure message.
    1411
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1412
    
                                                    
                                                
    1413
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1414
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1415
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1416
    
                                                    
                                                
    1417
        /// Compares two `int256` values. Expects first value to be greater than second.
    1418
        /// Formats values with decimals in failure message.
    1419
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1420
    
                                                    
                                                
    1421
        /// Compares two `int256` values. Expects first value to be greater than second.
    1422
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1423
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1424
    
                                                    
                                                
    1425
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1426
        function assertGt(uint256 left, uint256 right) external pure;
    1427
    
                                                    
                                                
    1428
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1429
        /// Includes error message into revert string on failure.
    1430
        function assertGt(uint256 left, uint256 right, string calldata error) external pure;
    1431
    
                                                    
                                                
    1432
        /// Compares two `int256` values. Expects first value to be greater than second.
    1433
        function assertGt(int256 left, int256 right) external pure;
    1434
    
                                                    
                                                
    1435
        /// Compares two `int256` values. Expects first value to be greater than second.
    1436
        /// Includes error message into revert string on failure.
    1437
        function assertGt(int256 left, int256 right, string calldata error) external pure;
    1438
    
                                                    
                                                
    1439
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1440
        /// Formats values with decimals in failure message.
    1441
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1442
    
                                                    
                                                
    1443
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1444
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1445
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1446
    
                                                    
                                                
    1447
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1448
        /// Formats values with decimals in failure message.
    1449
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1450
    
                                                    
                                                
    1451
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1452
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1453
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1454
    
                                                    
                                                
    1455
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1456
        function assertLe(uint256 left, uint256 right) external pure;
    1457
    
                                                    
                                                
    1458
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1459
        /// Includes error message into revert string on failure.
    1460
        function assertLe(uint256 left, uint256 right, string calldata error) external pure;
    1461
    
                                                    
                                                
    1462
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1463
        function assertLe(int256 left, int256 right) external pure;
    1464
    
                                                    
                                                
    1465
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1466
        /// Includes error message into revert string on failure.
    1467
        function assertLe(int256 left, int256 right, string calldata error) external pure;
    1468
    
                                                    
                                                
    1469
        /// Compares two `uint256` values. Expects first value to be less than second.
    1470
        /// Formats values with decimals in failure message.
    1471
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1472
    
                                                    
                                                
    1473
        /// Compares two `uint256` values. Expects first value to be less than second.
    1474
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1475
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1476
    
                                                    
                                                
    1477
        /// Compares two `int256` values. Expects first value to be less than second.
    1478
        /// Formats values with decimals in failure message.
    1479
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1480
    
                                                    
                                                
    1481
        /// Compares two `int256` values. Expects first value to be less than second.
    1482
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1483
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1484
    
                                                    
                                                
    1485
        /// Compares two `uint256` values. Expects first value to be less than second.
    1486
        function assertLt(uint256 left, uint256 right) external pure;
    1487
    
                                                    
                                                
    1488
        /// Compares two `uint256` values. Expects first value to be less than second.
    1489
        /// Includes error message into revert string on failure.
    1490
        function assertLt(uint256 left, uint256 right, string calldata error) external pure;
    1491
    
                                                    
                                                
    1492
        /// Compares two `int256` values. Expects first value to be less than second.
    1493
        function assertLt(int256 left, int256 right) external pure;
    1494
    
                                                    
                                                
    1495
        /// Compares two `int256` values. Expects first value to be less than second.
    1496
        /// Includes error message into revert string on failure.
    1497
        function assertLt(int256 left, int256 right, string calldata error) external pure;
    1498
    
                                                    
                                                
    1499
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1500
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1501
    
                                                    
                                                
    1502
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1503
        /// Includes error message into revert string on failure.
    1504
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1505
    
                                                    
                                                
    1506
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1507
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1508
    
                                                    
                                                
    1509
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1510
        /// Includes error message into revert string on failure.
    1511
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1512
    
                                                    
                                                
    1513
        /// Asserts that two `bool` values are not equal.
    1514
        function assertNotEq(bool left, bool right) external pure;
    1515
    
                                                    
                                                
    1516
        /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.
    1517
        function assertNotEq(bool left, bool right, string calldata error) external pure;
    1518
    
                                                    
                                                
    1519
        /// Asserts that two `string` values are not equal.
    1520
        function assertNotEq(string calldata left, string calldata right) external pure;
    1521
    
                                                    
                                                
    1522
        /// Asserts that two `string` values are not equal and includes error message into revert string on failure.
    1523
        function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;
    1524
    
                                                    
                                                
    1525
        /// Asserts that two `bytes` values are not equal.
    1526
        function assertNotEq(bytes calldata left, bytes calldata right) external pure;
    1527
    
                                                    
                                                
    1528
        /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.
    1529
        function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1530
    
                                                    
                                                
    1531
        /// Asserts that two arrays of `bool` values are not equal.
    1532
        function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;
    1533
    
                                                    
                                                
    1534
        /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.
    1535
        function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1536
    
                                                    
                                                
    1537
        /// Asserts that two arrays of `uint256` values are not equal.
    1538
        function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1539
    
                                                    
                                                
    1540
        /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.
    1541
        function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1542
    
                                                    
                                                
    1543
        /// Asserts that two arrays of `int256` values are not equal.
    1544
        function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;
    1545
    
                                                    
                                                
    1546
        /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.
    1547
        function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1548
    
                                                    
                                                
    1549
        /// Asserts that two `uint256` values are not equal.
    1550
        function assertNotEq(uint256 left, uint256 right) external pure;
    1551
    
                                                    
                                                
    1552
        /// Asserts that two arrays of `address` values are not equal.
    1553
        function assertNotEq(address[] calldata left, address[] calldata right) external pure;
    1554
    
                                                    
                                                
    1555
        /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.
    1556
        function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1557
    
                                                    
                                                
    1558
        /// Asserts that two arrays of `bytes32` values are not equal.
    1559
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1560
    
                                                    
                                                
    1561
        /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.
    1562
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1563
    
                                                    
                                                
    1564
        /// Asserts that two arrays of `string` values are not equal.
    1565
        function assertNotEq(string[] calldata left, string[] calldata right) external pure;
    1566
    
                                                    
                                                
    1567
        /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.
    1568
        function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1569
    
                                                    
                                                
    1570
        /// Asserts that two arrays of `bytes` values are not equal.
    1571
        function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1572
    
                                                    
                                                
    1573
        /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.
    1574
        function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1575
    
                                                    
                                                
    1576
        /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.
    1577
        function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;
    1578
    
                                                    
                                                
    1579
        /// Asserts that two `int256` values are not equal.
    1580
        function assertNotEq(int256 left, int256 right) external pure;
    1581
    
                                                    
                                                
    1582
        /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.
    1583
        function assertNotEq(int256 left, int256 right, string calldata error) external pure;
    1584
    
                                                    
                                                
    1585
        /// Asserts that two `address` values are not equal.
    1586
        function assertNotEq(address left, address right) external pure;
    1587
    
                                                    
                                                
    1588
        /// Asserts that two `address` values are not equal and includes error message into revert string on failure.
    1589
        function assertNotEq(address left, address right, string calldata error) external pure;
    1590
    
                                                    
                                                
    1591
        /// Asserts that two `bytes32` values are not equal.
    1592
        function assertNotEq(bytes32 left, bytes32 right) external pure;
    1593
    
                                                    
                                                
    1594
        /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.
    1595
        function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1596
    
                                                    
                                                
    1597
        /// Asserts that the given condition is true.
    1598
        function assertTrue(bool condition) external pure;
    1599
    
                                                    
                                                
    1600
        /// Asserts that the given condition is true and includes error message into revert string on failure.
    1601
        function assertTrue(bool condition, string calldata error) external pure;
    1602
    
                                                    
                                                
    1603
        /// If the condition is false, discard this run's fuzz inputs and generate new ones.
    1604
        function assume(bool condition) external pure;
    1605
    
                                                    
                                                
    1606
        /// Discard this run's fuzz inputs and generate new ones if next call reverted.
    1607
        function assumeNoRevert() external pure;
    1608
    
                                                    
                                                
    1609
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.
    1610
        function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;
    1611
    
                                                    
                                                
    1612
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.
    1613
        function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;
    1614
    
                                                    
                                                
    1615
        /// Writes a breakpoint to jump to in the debugger.
    1616
        function breakpoint(string calldata char) external pure;
    1617
    
                                                    
                                                
    1618
        /// Writes a conditional breakpoint to jump to in the debugger.
    1619
        function breakpoint(string calldata char, bool value) external pure;
    1620
    
                                                    
                                                
    1621
        /// Returns the Foundry version.
    1622
        /// Format: <cargo_version>-<tag>+<git_sha_short>.<unix_build_timestamp>.<profile>
    1623
        /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug
    1624
        /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.
    1625
        /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)
    1626
        /// to compare timestamps while ignoring minor time differences.
    1627
        function getFoundryVersion() external view returns (string memory version);
    1628
    
                                                    
                                                
    1629
        /// Returns the RPC url for the given alias.
    1630
        function rpcUrl(string calldata rpcAlias) external view returns (string memory json);
    1631
    
                                                    
                                                
    1632
        /// Returns all rpc urls and their aliases as structs.
    1633
        function rpcUrlStructs() external view returns (Rpc[] memory urls);
    1634
    
                                                    
                                                
    1635
        /// Returns all rpc urls and their aliases `[alias, url][]`.
    1636
        function rpcUrls() external view returns (string[2][] memory urls);
    1637
    
                                                    
                                                
    1638
        /// Suspends execution of the main thread for `duration` milliseconds.
    1639
        function sleep(uint256 duration) external;
    1640
    
                                                    
                                                
    1641
        // ======== Toml ========
    1642
    
                                                    
                                                
    1643
        /// Checks if `key` exists in a TOML table.
    1644
        function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);
    1645
    
                                                    
                                                
    1646
        /// Parses a string of TOML data at `key` and coerces it to `address`.
    1647
        function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);
    1648
    
                                                    
                                                
    1649
        /// Parses a string of TOML data at `key` and coerces it to `address[]`.
    1650
        function parseTomlAddressArray(string calldata toml, string calldata key)
    1651
            external
    1652
            pure
    1653
            returns (address[] memory);
    1654
    
                                                    
                                                
    1655
        /// Parses a string of TOML data at `key` and coerces it to `bool`.
    1656
        function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);
    1657
    
                                                    
                                                
    1658
        /// Parses a string of TOML data at `key` and coerces it to `bool[]`.
    1659
        function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);
    1660
    
                                                    
                                                
    1661
        /// Parses a string of TOML data at `key` and coerces it to `bytes`.
    1662
        function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);
    1663
    
                                                    
                                                
    1664
        /// Parses a string of TOML data at `key` and coerces it to `bytes32`.
    1665
        function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);
    1666
    
                                                    
                                                
    1667
        /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.
    1668
        function parseTomlBytes32Array(string calldata toml, string calldata key)
    1669
            external
    1670
            pure
    1671
            returns (bytes32[] memory);
    1672
    
                                                    
                                                
    1673
        /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.
    1674
        function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);
    1675
    
                                                    
                                                
    1676
        /// Parses a string of TOML data at `key` and coerces it to `int256`.
    1677
        function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);
    1678
    
                                                    
                                                
    1679
        /// Parses a string of TOML data at `key` and coerces it to `int256[]`.
    1680
        function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);
    1681
    
                                                    
                                                
    1682
        /// Returns an array of all the keys in a TOML table.
    1683
        function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);
    1684
    
                                                    
                                                
    1685
        /// Parses a string of TOML data at `key` and coerces it to `string`.
    1686
        function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);
    1687
    
                                                    
                                                
    1688
        /// Parses a string of TOML data at `key` and coerces it to `string[]`.
    1689
        function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);
    1690
    
                                                    
                                                
    1691
        /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.
    1692
        function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)
    1693
            external
    1694
            pure
    1695
            returns (bytes memory);
    1696
    
                                                    
                                                
    1697
        /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.
    1698
        function parseTomlType(string calldata toml, string calldata typeDescription)
    1699
            external
    1700
            pure
    1701
            returns (bytes memory);
    1702
    
                                                    
                                                
    1703
        /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.
    1704
        function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)
    1705
            external
    1706
            pure
    1707
            returns (bytes memory);
    1708
    
                                                    
                                                
    1709
        /// Parses a string of TOML data at `key` and coerces it to `uint256`.
    1710
        function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);
    1711
    
                                                    
                                                
    1712
        /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.
    1713
        function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);
    1714
    
                                                    
                                                
    1715
        /// ABI-encodes a TOML table.
    1716
        function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);
    1717
    
                                                    
                                                
    1718
        /// ABI-encodes a TOML table at `key`.
    1719
        function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);
    1720
    
                                                    
                                                
    1721
        /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.
    1722
        function writeToml(string calldata json, string calldata path) external;
    1723
    
                                                    
                                                
    1724
        /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = <value_key.>
    1725
        /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.
    1726
        function writeToml(string calldata json, string calldata path, string calldata valueKey) external;
    1727
    
                                                    
                                                
    1728
        // ======== Utilities ========
    1729
    
                                                    
                                                
    1730
        /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.
    1731
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)
    1732
            external
    1733
            pure
    1734
            returns (address);
    1735
    
                                                    
                                                
    1736
        /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.
    1737
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);
    1738
    
                                                    
                                                
    1739
        /// Compute the address a contract will be deployed at for a given deployer address and nonce.
    1740
        function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);
    1741
    
                                                    
                                                
    1742
        /// Utility cheatcode to copy storage of `from` contract to another `to` contract.
    1743
        function copyStorage(address from, address to) external;
    1744
    
                                                    
                                                
    1745
        /// Returns ENS namehash for provided string.
    1746
        function ensNamehash(string calldata name) external pure returns (bytes32);
    1747
    
                                                    
                                                
    1748
        /// Gets the label for the specified address.
    1749
        function getLabel(address account) external view returns (string memory currentLabel);
    1750
    
                                                    
                                                
    1751
        /// Labels an address in call traces.
    1752
        function label(address account, string calldata newLabel) external;
    1753
    
                                                    
                                                
    1754
        /// Pauses collection of call traces. Useful in cases when you want to skip tracing of
    1755
        /// complex calls which are not useful for debugging.
    1756
        function pauseTracing() external view;
    1757
    
                                                    
                                                
    1758
        /// Returns a random `address`.
    1759
        function randomAddress() external returns (address);
    1760
    
                                                    
                                                
    1761
        /// Returns a random `bool`.
    1762
        function randomBool() external view returns (bool);
    1763
    
                                                    
                                                
    1764
        /// Returns a random byte array value of the given length.
    1765
        function randomBytes(uint256 len) external view returns (bytes memory);
    1766
    
                                                    
                                                
    1767
        /// Returns a random fixed-size byte array of length 4.
    1768
        function randomBytes4() external view returns (bytes4);
    1769
    
                                                    
                                                
    1770
        /// Returns a random fixed-size byte array of length 8.
    1771
        function randomBytes8() external view returns (bytes8);
    1772
    
                                                    
                                                
    1773
        /// Returns a random `int256` value.
    1774
        function randomInt() external view returns (int256);
    1775
    
                                                    
                                                
    1776
        /// Returns a random `int256` value of given bits.
    1777
        function randomInt(uint256 bits) external view returns (int256);
    1778
    
                                                    
                                                
    1779
        /// Returns a random uint256 value.
    1780
        function randomUint() external returns (uint256);
    1781
    
                                                    
                                                
    1782
        /// Returns random uint256 value between the provided range (=min..=max).
    1783
        function randomUint(uint256 min, uint256 max) external returns (uint256);
    1784
    
                                                    
                                                
    1785
        /// Returns a random `uint256` value of given bits.
    1786
        function randomUint(uint256 bits) external view returns (uint256);
    1787
    
                                                    
                                                
    1788
        /// Unpauses collection of call traces.
    1789
        function resumeTracing() external view;
    1790
    
                                                    
                                                
    1791
        /// Utility cheatcode to set arbitrary storage for given target address.
    1792
        function setArbitraryStorage(address target) external;
    1793
    
                                                    
                                                
    1794
        /// Encodes a `bytes` value to a base64url string.
    1795
        function toBase64URL(bytes calldata data) external pure returns (string memory);
    1796
    
                                                    
                                                
    1797
        /// Encodes a `string` value to a base64url string.
    1798
        function toBase64URL(string calldata data) external pure returns (string memory);
    1799
    
                                                    
                                                
    1800
        /// Encodes a `bytes` value to a base64 string.
    1801
        function toBase64(bytes calldata data) external pure returns (string memory);
    1802
    
                                                    
                                                
    1803
        /// Encodes a `string` value to a base64 string.
    1804
        function toBase64(string calldata data) external pure returns (string memory);
    1805
    }
    1806
    
                                                    
                                                
    1807
    /// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
    1808
    /// in tests, but it is not recommended to use these cheats in scripts.
    1809
    interface Vm is VmSafe {
    1810
        // ======== EVM ========
    1811
    
                                                    
                                                
    1812
        /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.
    1813
        function activeFork() external view returns (uint256 forkId);
    1814
    
                                                    
                                                
    1815
        /// In forking mode, explicitly grant the given address cheatcode access.
    1816
        function allowCheatcodes(address account) external;
    1817
    
                                                    
                                                
    1818
        /// Sets `block.blobbasefee`
    1819
        function blobBaseFee(uint256 newBlobBaseFee) external;
    1820
    
                                                    
                                                
    1821
        /// Sets the blobhashes in the transaction.
    1822
        /// Not available on EVM versions before Cancun.
    1823
        /// If used on unsupported EVM versions it will revert.
    1824
        function blobhashes(bytes32[] calldata hashes) external;
    1825
    
                                                    
                                                
    1826
        /// Sets `block.chainid`.
    1827
        function chainId(uint256 newChainId) external;
    1828
    
                                                    
                                                
    1829
        /// Clears all mocked calls.
    1830
        function clearMockedCalls() external;
    1831
    
                                                    
                                                
    1832
        /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.
    1833
        function cloneAccount(address source, address target) external;
    1834
    
                                                    
                                                
    1835
        /// Sets `block.coinbase`.
    1836
        function coinbase(address newCoinbase) external;
    1837
    
                                                    
                                                
    1838
        /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.
    1839
        function createFork(string calldata urlOrAlias) external returns (uint256 forkId);
    1840
    
                                                    
                                                
    1841
        /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.
    1842
        function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    1843
    
                                                    
                                                
    1844
        /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,
    1845
        /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.
    1846
        function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    1847
    
                                                    
                                                
    1848
        /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.
    1849
        function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);
    1850
    
                                                    
                                                
    1851
        /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.
    1852
        function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    1853
    
                                                    
                                                
    1854
        /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,
    1855
        /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.
    1856
        function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    1857
    
                                                    
                                                
    1858
        /// Sets an address' balance.
    1859
        function deal(address account, uint256 newBalance) external;
    1860
    
                                                    
                                                
    1861
        /// Removes the snapshot with the given ID created by `snapshot`.
    1862
        /// Takes the snapshot ID to delete.
    1863
        /// Returns `true` if the snapshot was successfully deleted.
    1864
        /// Returns `false` if the snapshot does not exist.
    1865
        function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);
    1866
    
                                                    
                                                
    1867
        /// Removes _all_ snapshots previously created by `snapshot`.
    1868
        function deleteStateSnapshots() external;
    1869
    
                                                    
                                                
    1870
        /// Sets `block.difficulty`.
    1871
        /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.
    1872
        /// Reverts if used on unsupported EVM versions.
    1873
        function difficulty(uint256 newDifficulty) external;
    1874
    
                                                    
                                                
    1875
        /// Dump a genesis JSON file's `allocs` to disk.
    1876
        function dumpState(string calldata pathToStateJson) external;
    1877
    
                                                    
                                                
    1878
        /// Sets an address' code.
    1879
        function etch(address target, bytes calldata newRuntimeBytecode) external;
    1880
    
                                                    
                                                
    1881
        /// Sets `block.basefee`.
    1882
        function fee(uint256 newBasefee) external;
    1883
    
                                                    
                                                
    1884
        /// Gets the blockhashes from the current transaction.
    1885
        /// Not available on EVM versions before Cancun.
    1886
        /// If used on unsupported EVM versions it will revert.
    1887
        function getBlobhashes() external view returns (bytes32[] memory hashes);
    1888
    
                                                    
                                                
    1889
        /// Returns true if the account is marked as persistent.
    1890
        function isPersistent(address account) external view returns (bool persistent);
    1891
    
                                                    
                                                
    1892
        /// Load a genesis JSON file's `allocs` into the in-memory EVM state.
    1893
        function loadAllocs(string calldata pathToAllocsJson) external;
    1894
    
                                                    
                                                
    1895
        /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
    1896
        /// Meaning, changes made to the state of this account will be kept when switching forks.
    1897
        function makePersistent(address account) external;
    1898
    
                                                    
                                                
    1899
        /// See `makePersistent(address)`.
    1900
        function makePersistent(address account0, address account1) external;
    1901
    
                                                    
                                                
    1902
        /// See `makePersistent(address)`.
    1903
        function makePersistent(address account0, address account1, address account2) external;
    1904
    
                                                    
                                                
    1905
        /// See `makePersistent(address)`.
    1906
        function makePersistent(address[] calldata accounts) external;
    1907
    
                                                    
                                                
    1908
        /// Reverts a call to an address with specified revert data.
    1909
        function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;
    1910
    
                                                    
                                                
    1911
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    1912
        function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)
    1913
            external;
    1914
    
                                                    
                                                
    1915
        /// Reverts a call to an address with specified revert data.
    1916
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    1917
        function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;
    1918
    
                                                    
                                                
    1919
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    1920
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    1921
        function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;
    1922
    
                                                    
                                                
    1923
        /// Mocks a call to an address, returning specified data.
    1924
        /// Calldata can either be strict or a partial match, e.g. if you only
    1925
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    1926
        /// function will be mocked.
    1927
        function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;
    1928
    
                                                    
                                                
    1929
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    1930
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    1931
        function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;
    1932
    
                                                    
                                                
    1933
        /// Mocks a call to an address, returning specified data.
    1934
        /// Calldata can either be strict or a partial match, e.g. if you only
    1935
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    1936
        /// function will be mocked.
    1937
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    1938
        function mockCall(address callee, bytes4 data, bytes calldata returnData) external;
    1939
    
                                                    
                                                
    1940
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    1941
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    1942
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    1943
        function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;
    1944
    
                                                    
                                                
    1945
        /// Mocks multiple calls to an address, returning specified data for each call.
    1946
        function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;
    1947
    
                                                    
                                                
    1948
        /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.
    1949
        function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;
    1950
    
                                                    
                                                
    1951
        /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls
    1952
        /// `target` with the same calldata. This functionality is similar to a delegate call made to
    1953
        /// `target` contract from `callee`.
    1954
        /// Can be used to substitute a call to a function with another implementation that captures
    1955
        /// the primary logic of the original function but is easier to reason about.
    1956
        /// If calldata is not a strict match then partial match by selector is attempted.
    1957
        function mockFunction(address callee, address target, bytes calldata data) external;
    1958
    
                                                    
                                                
    1959
        /// Sets the *next* call's `msg.sender` to be the input address.
    1960
        function prank(address msgSender) external;
    1961
    
                                                    
                                                
    1962
        /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    1963
        function prank(address msgSender, address txOrigin) external;
    1964
    
                                                    
                                                
    1965
        /// Sets the *next* delegate call's `msg.sender` to be the input address.
    1966
        function prank(address msgSender, bool delegateCall) external;
    1967
    
                                                    
                                                
    1968
        /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    1969
        function prank(address msgSender, address txOrigin, bool delegateCall) external;
    1970
    
                                                    
                                                
    1971
        /// Sets `block.prevrandao`.
    1972
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    1973
        /// If used on unsupported EVM versions it will revert.
    1974
        function prevrandao(bytes32 newPrevrandao) external;
    1975
    
                                                    
                                                
    1976
        /// Sets `block.prevrandao`.
    1977
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    1978
        /// If used on unsupported EVM versions it will revert.
    1979
        function prevrandao(uint256 newPrevrandao) external;
    1980
    
                                                    
                                                
    1981
        /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.
    1982
        function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);
    1983
    
                                                    
                                                
    1984
        /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.
    1985
        function resetNonce(address account) external;
    1986
    
                                                    
                                                
    1987
        /// Revert the state of the EVM to a previous snapshot
    1988
        /// Takes the snapshot ID to revert to.
    1989
        /// Returns `true` if the snapshot was successfully reverted.
    1990
        /// Returns `false` if the snapshot does not exist.
    1991
        /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.
    1992
        function revertToState(uint256 snapshotId) external returns (bool success);
    1993
    
                                                    
                                                
    1994
        /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots
    1995
        /// Takes the snapshot ID to revert to.
    1996
        /// Returns `true` if the snapshot was successfully reverted and deleted.
    1997
        /// Returns `false` if the snapshot does not exist.
    1998
        function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);
    1999
    
                                                    
                                                
    2000
        /// Revokes persistent status from the address, previously added via `makePersistent`.
    2001
        function revokePersistent(address account) external;
    2002
    
                                                    
                                                
    2003
        /// See `revokePersistent(address)`.
    2004
        function revokePersistent(address[] calldata accounts) external;
    2005
    
                                                    
                                                
    2006
        /// Sets `block.height`.
    2007
        function roll(uint256 newHeight) external;
    2008
    
                                                    
                                                
    2009
        /// Updates the currently active fork to given block number
    2010
        /// This is similar to `roll` but for the currently active fork.
    2011
        function rollFork(uint256 blockNumber) external;
    2012
    
                                                    
                                                
    2013
        /// Updates the currently active fork to given transaction. This will `rollFork` with the number
    2014
        /// of the block the transaction was mined in and replays all transaction mined before it in the block.
    2015
        function rollFork(bytes32 txHash) external;
    2016
    
                                                    
                                                
    2017
        /// Updates the given fork to given block number.
    2018
        function rollFork(uint256 forkId, uint256 blockNumber) external;
    2019
    
                                                    
                                                
    2020
        /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.
    2021
        function rollFork(uint256 forkId, bytes32 txHash) external;
    2022
    
                                                    
                                                
    2023
        /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
    2024
        function selectFork(uint256 forkId) external;
    2025
    
                                                    
                                                
    2026
        /// Set blockhash for the current block.
    2027
        /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.
    2028
        function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;
    2029
    
                                                    
                                                
    2030
        /// Sets the nonce of an account. Must be higher than the current nonce of the account.
    2031
        function setNonce(address account, uint64 newNonce) external;
    2032
    
                                                    
                                                
    2033
        /// Sets the nonce of an account to an arbitrary value.
    2034
        function setNonceUnsafe(address account, uint64 newNonce) external;
    2035
    
                                                    
                                                
    2036
        /// Snapshot capture the gas usage of the last call by name from the callee perspective.
    2037
        function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);
    2038
    
                                                    
                                                
    2039
        /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.
    2040
        function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2041
    
                                                    
                                                
    2042
        /// Snapshot the current state of the evm.
    2043
        /// Returns the ID of the snapshot that was created.
    2044
        /// To revert a snapshot use `revertToState`.
    2045
        function snapshotState() external returns (uint256 snapshotId);
    2046
    
                                                    
                                                
    2047
        /// Snapshot capture an arbitrary numerical value by name.
    2048
        /// The group name is derived from the contract name.
    2049
        function snapshotValue(string calldata name, uint256 value) external;
    2050
    
                                                    
                                                
    2051
        /// Snapshot capture an arbitrary numerical value by name in a group.
    2052
        function snapshotValue(string calldata group, string calldata name, uint256 value) external;
    2053
    
                                                    
                                                
    2054
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.
    2055
        function startPrank(address msgSender) external;
    2056
    
                                                    
                                                
    2057
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2058
        function startPrank(address msgSender, address txOrigin) external;
    2059
    
                                                    
                                                
    2060
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.
    2061
        function startPrank(address msgSender, bool delegateCall) external;
    2062
    
                                                    
                                                
    2063
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2064
        function startPrank(address msgSender, address txOrigin, bool delegateCall) external;
    2065
    
                                                    
                                                
    2066
        /// Start a snapshot capture of the current gas usage by name.
    2067
        /// The group name is derived from the contract name.
    2068
        function startSnapshotGas(string calldata name) external;
    2069
    
                                                    
                                                
    2070
        /// Start a snapshot capture of the current gas usage by name in a group.
    2071
        function startSnapshotGas(string calldata group, string calldata name) external;
    2072
    
                                                    
                                                
    2073
        /// Resets subsequent calls' `msg.sender` to be `address(this)`.
    2074
        function stopPrank() external;
    2075
    
                                                    
                                                
    2076
        /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.
    2077
        function stopSnapshotGas() external returns (uint256 gasUsed);
    2078
    
                                                    
                                                
    2079
        /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.
    2080
        /// The group name is derived from the contract name.
    2081
        function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);
    2082
    
                                                    
                                                
    2083
        /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.
    2084
        function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2085
    
                                                    
                                                
    2086
        /// Stores a value to an address' storage slot.
    2087
        function store(address target, bytes32 slot, bytes32 value) external;
    2088
    
                                                    
                                                
    2089
        /// Fetches the given transaction from the active fork and executes it on the current state.
    2090
        function transact(bytes32 txHash) external;
    2091
    
                                                    
                                                
    2092
        /// Fetches the given transaction from the given fork and executes it on the current state.
    2093
        function transact(uint256 forkId, bytes32 txHash) external;
    2094
    
                                                    
                                                
    2095
        /// Sets `tx.gasprice`.
    2096
        function txGasPrice(uint256 newGasPrice) external;
    2097
    
                                                    
                                                
    2098
        /// Sets `block.timestamp`.
    2099
        function warp(uint256 newTimestamp) external;
    2100
    
                                                    
                                                
    2101
        /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.
    2102
        function deleteSnapshot(uint256 snapshotId) external returns (bool success);
    2103
    
                                                    
                                                
    2104
        /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.
    2105
        function deleteSnapshots() external;
    2106
    
                                                    
                                                
    2107
        /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.
    2108
        function revertToAndDelete(uint256 snapshotId) external returns (bool success);
    2109
    
                                                    
                                                
    2110
        /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.
    2111
        function revertTo(uint256 snapshotId) external returns (bool success);
    2112
    
                                                    
                                                
    2113
        /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.
    2114
        function snapshot() external returns (uint256 snapshotId);
    2115
    
                                                    
                                                
    2116
        // ======== Testing ========
    2117
    
                                                    
                                                
    2118
        /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2119
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;
    2120
    
                                                    
                                                
    2121
        /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2122
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)
    2123
            external;
    2124
    
                                                    
                                                
    2125
        /// Expects a call to an address with the specified calldata.
    2126
        /// Calldata can either be a strict or a partial match.
    2127
        function expectCall(address callee, bytes calldata data) external;
    2128
    
                                                    
                                                
    2129
        /// Expects given number of calls to an address with the specified calldata.
    2130
        function expectCall(address callee, bytes calldata data, uint64 count) external;
    2131
    
                                                    
                                                
    2132
        /// Expects a call to an address with the specified `msg.value` and calldata.
    2133
        function expectCall(address callee, uint256 msgValue, bytes calldata data) external;
    2134
    
                                                    
                                                
    2135
        /// Expects given number of calls to an address with the specified `msg.value` and calldata.
    2136
        function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;
    2137
    
                                                    
                                                
    2138
        /// Expect a call to an address with the specified `msg.value`, gas, and calldata.
    2139
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;
    2140
    
                                                    
                                                
    2141
        /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.
    2142
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;
    2143
    
                                                    
                                                
    2144
        /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2145
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2146
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2147
        function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)
    2148
            external;
    2149
    
                                                    
                                                
    2150
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2151
        function expectEmitAnonymous(
    2152
            bool checkTopic0,
    2153
            bool checkTopic1,
    2154
            bool checkTopic2,
    2155
            bool checkTopic3,
    2156
            bool checkData,
    2157
            address emitter
    2158
        ) external;
    2159
    
                                                    
                                                
    2160
        /// Prepare an expected anonymous log with all topic and data checks enabled.
    2161
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2162
        /// logs were emitted in the expected order with the expected topics and data.
    2163
        function expectEmitAnonymous() external;
    2164
    
                                                    
                                                
    2165
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2166
        function expectEmitAnonymous(address emitter) external;
    2167
    
                                                    
                                                
    2168
        /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2169
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2170
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2171
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;
    2172
    
                                                    
                                                
    2173
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2174
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)
    2175
            external;
    2176
    
                                                    
                                                
    2177
        /// Prepare an expected log with all topic and data checks enabled.
    2178
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2179
        /// logs were emitted in the expected order with the expected topics and data.
    2180
        function expectEmit() external;
    2181
    
                                                    
                                                
    2182
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2183
        function expectEmit(address emitter) external;
    2184
    
                                                    
                                                
    2185
        /// Expect a given number of logs with the provided topics.
    2186
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;
    2187
    
                                                    
                                                
    2188
        /// Expect a given number of logs from a specific emitter with the provided topics.
    2189
        function expectEmit(
    2190
            bool checkTopic1,
    2191
            bool checkTopic2,
    2192
            bool checkTopic3,
    2193
            bool checkData,
    2194
            address emitter,
    2195
            uint64 count
    2196
        ) external;
    2197
    
                                                    
                                                
    2198
        /// Expect a given number of logs with all topic and data checks enabled.
    2199
        function expectEmit(uint64 count) external;
    2200
    
                                                    
                                                
    2201
        /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.
    2202
        function expectEmit(address emitter, uint64 count) external;
    2203
    
                                                    
                                                
    2204
        /// Expects an error on next call that starts with the revert data.
    2205
        function expectPartialRevert(bytes4 revertData) external;
    2206
    
                                                    
                                                
    2207
        /// Expects an error on next call to reverter address, that starts with the revert data.
    2208
        function expectPartialRevert(bytes4 revertData, address reverter) external;
    2209
    
                                                    
                                                
    2210
        /// Expects an error on next call with any revert data.
    2211
        function expectRevert() external;
    2212
    
                                                    
                                                
    2213
        /// Expects an error on next call that exactly matches the revert data.
    2214
        function expectRevert(bytes4 revertData) external;
    2215
    
                                                    
                                                
    2216
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.
    2217
        function expectRevert(bytes4 revertData, address reverter, uint64 count) external;
    2218
    
                                                    
                                                
    2219
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.
    2220
        function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;
    2221
    
                                                    
                                                
    2222
        /// Expects an error on next call that exactly matches the revert data.
    2223
        function expectRevert(bytes calldata revertData) external;
    2224
    
                                                    
                                                
    2225
        /// Expects an error with any revert data on next call to reverter address.
    2226
        function expectRevert(address reverter) external;
    2227
    
                                                    
                                                
    2228
        /// Expects an error from reverter address on next call, with any revert data.
    2229
        function expectRevert(bytes4 revertData, address reverter) external;
    2230
    
                                                    
                                                
    2231
        /// Expects an error from reverter address on next call, that exactly matches the revert data.
    2232
        function expectRevert(bytes calldata revertData, address reverter) external;
    2233
    
                                                    
                                                
    2234
        /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.
    2235
        function expectRevert(uint64 count) external;
    2236
    
                                                    
                                                
    2237
        /// Expects a `count` number of reverts from the upcoming calls that match the revert data.
    2238
        function expectRevert(bytes4 revertData, uint64 count) external;
    2239
    
                                                    
                                                
    2240
        /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.
    2241
        function expectRevert(bytes calldata revertData, uint64 count) external;
    2242
    
                                                    
                                                
    2243
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address.
    2244
        function expectRevert(address reverter, uint64 count) external;
    2245
    
                                                    
                                                
    2246
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other
    2247
        /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.
    2248
        function expectSafeMemory(uint64 min, uint64 max) external;
    2249
    
                                                    
                                                
    2250
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.
    2251
        /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges
    2252
        /// to the set.
    2253
        function expectSafeMemoryCall(uint64 min, uint64 max) external;
    2254
    
                                                    
                                                
    2255
        /// Marks a test as skipped. Must be called at the top level of a test.
    2256
        function skip(bool skipTest) external;
    2257
    
                                                    
                                                
    2258
        /// Marks a test as skipped with a reason. Must be called at the top level of a test.
    2259
        function skip(bool skipTest, string calldata reason) external;
    2260
    
                                                    
                                                
    2261
        /// Stops all safe memory expectation in the current subcontext.
    2262
        function stopExpectSafeMemory() external;
    2263
    }
    2264
    
                                                    
                                                
    7.7% lib/openzeppelin-contracts/lib/forge-std/src/console.sol
    Lines covered: 1 / 13 (7.7%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    ✓ 15
    library console {
    5
        address constant CONSOLE_ADDRESS =
    6
            0x000000000000000000636F6e736F6c652e6c6f67;
    7
    
                                                    
                                                
    8
        function _sendLogPayloadImplementation(bytes memory payload) internal view {
    9
            address consoleAddress = CONSOLE_ADDRESS;
    10
            /// @solidity memory-safe-assembly
    11
            assembly {
    12
                pop(
    13
                    staticcall(
    14
                        gas(),
    15
                        consoleAddress,
    16
                        add(payload, 32),
    17
                        mload(payload),
    18
                        0,
    19
                        0
    20
                    )
    21
                )
    22
            }
    23
        }
    24
    
                                                    
                                                
    25
        function _castToPure(
    26
          function(bytes memory) internal view fnIn
    27
        ) internal pure returns (function(bytes memory) pure fnOut) {
    28
            assembly {
    29
                fnOut := fnIn
    30
            }
    31
        }
    32
    
                                                    
                                                
    33
        function _sendLogPayload(bytes memory payload) internal pure {
    34
            _castToPure(_sendLogPayloadImplementation)(payload);
    35
        }
    36
    
                                                    
                                                
    37
        function log() internal pure {
    38
            _sendLogPayload(abi.encodeWithSignature("log()"));
    39
        }
    40
    
                                                    
                                                
    41
        function logInt(int256 p0) internal pure {
    42
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    43
        }
    44
    
                                                    
                                                
    45
        function logUint(uint256 p0) internal pure {
    46
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    47
        }
    48
    
                                                    
                                                
    49
        function logString(string memory p0) internal pure {
    50
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    51
        }
    52
    
                                                    
                                                
    53
        function logBool(bool p0) internal pure {
    54
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    55
        }
    56
    
                                                    
                                                
    57
        function logAddress(address p0) internal pure {
    58
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    59
        }
    60
    
                                                    
                                                
    61
        function logBytes(bytes memory p0) internal pure {
    62
            _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    63
        }
    64
    
                                                    
                                                
    65
        function logBytes1(bytes1 p0) internal pure {
    66
            _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    67
        }
    68
    
                                                    
                                                
    69
        function logBytes2(bytes2 p0) internal pure {
    70
            _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    71
        }
    72
    
                                                    
                                                
    73
        function logBytes3(bytes3 p0) internal pure {
    74
            _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    75
        }
    76
    
                                                    
                                                
    77
        function logBytes4(bytes4 p0) internal pure {
    78
            _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    79
        }
    80
    
                                                    
                                                
    81
        function logBytes5(bytes5 p0) internal pure {
    82
            _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    83
        }
    84
    
                                                    
                                                
    85
        function logBytes6(bytes6 p0) internal pure {
    86
            _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    87
        }
    88
    
                                                    
                                                
    89
        function logBytes7(bytes7 p0) internal pure {
    90
            _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    91
        }
    92
    
                                                    
                                                
    93
        function logBytes8(bytes8 p0) internal pure {
    94
            _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    95
        }
    96
    
                                                    
                                                
    97
        function logBytes9(bytes9 p0) internal pure {
    98
            _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    99
        }
    100
    
                                                    
                                                
    101
        function logBytes10(bytes10 p0) internal pure {
    102
            _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    103
        }
    104
    
                                                    
                                                
    105
        function logBytes11(bytes11 p0) internal pure {
    106
            _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    107
        }
    108
    
                                                    
                                                
    109
        function logBytes12(bytes12 p0) internal pure {
    110
            _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    111
        }
    112
    
                                                    
                                                
    113
        function logBytes13(bytes13 p0) internal pure {
    114
            _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    115
        }
    116
    
                                                    
                                                
    117
        function logBytes14(bytes14 p0) internal pure {
    118
            _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    119
        }
    120
    
                                                    
                                                
    121
        function logBytes15(bytes15 p0) internal pure {
    122
            _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    123
        }
    124
    
                                                    
                                                
    125
        function logBytes16(bytes16 p0) internal pure {
    126
            _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    127
        }
    128
    
                                                    
                                                
    129
        function logBytes17(bytes17 p0) internal pure {
    130
            _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    131
        }
    132
    
                                                    
                                                
    133
        function logBytes18(bytes18 p0) internal pure {
    134
            _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    135
        }
    136
    
                                                    
                                                
    137
        function logBytes19(bytes19 p0) internal pure {
    138
            _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    139
        }
    140
    
                                                    
                                                
    141
        function logBytes20(bytes20 p0) internal pure {
    142
            _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    143
        }
    144
    
                                                    
                                                
    145
        function logBytes21(bytes21 p0) internal pure {
    146
            _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    147
        }
    148
    
                                                    
                                                
    149
        function logBytes22(bytes22 p0) internal pure {
    150
            _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    151
        }
    152
    
                                                    
                                                
    153
        function logBytes23(bytes23 p0) internal pure {
    154
            _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    155
        }
    156
    
                                                    
                                                
    157
        function logBytes24(bytes24 p0) internal pure {
    158
            _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    159
        }
    160
    
                                                    
                                                
    161
        function logBytes25(bytes25 p0) internal pure {
    162
            _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    163
        }
    164
    
                                                    
                                                
    165
        function logBytes26(bytes26 p0) internal pure {
    166
            _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    167
        }
    168
    
                                                    
                                                
    169
        function logBytes27(bytes27 p0) internal pure {
    170
            _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    171
        }
    172
    
                                                    
                                                
    173
        function logBytes28(bytes28 p0) internal pure {
    174
            _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    175
        }
    176
    
                                                    
                                                
    177
        function logBytes29(bytes29 p0) internal pure {
    178
            _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    179
        }
    180
    
                                                    
                                                
    181
        function logBytes30(bytes30 p0) internal pure {
    182
            _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    183
        }
    184
    
                                                    
                                                
    185
        function logBytes31(bytes31 p0) internal pure {
    186
            _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    187
        }
    188
    
                                                    
                                                
    189
        function logBytes32(bytes32 p0) internal pure {
    190
            _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    191
        }
    192
    
                                                    
                                                
    193
        function log(uint256 p0) internal pure {
    194
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    195
        }
    196
    
                                                    
                                                
    197
        function log(int256 p0) internal pure {
    198
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    199
        }
    200
    
                                                    
                                                
    201
        function log(string memory p0) internal pure {
    202
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    203
        }
    204
    
                                                    
                                                
    205
        function log(bool p0) internal pure {
    206
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    207
        }
    208
    
                                                    
                                                
    209
        function log(address p0) internal pure {
    210
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    211
        }
    212
    
                                                    
                                                
    213
        function log(uint256 p0, uint256 p1) internal pure {
    214
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    215
        }
    216
    
                                                    
                                                
    217
        function log(uint256 p0, string memory p1) internal pure {
    218
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    219
        }
    220
    
                                                    
                                                
    221
        function log(uint256 p0, bool p1) internal pure {
    222
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    223
        }
    224
    
                                                    
                                                
    225
        function log(uint256 p0, address p1) internal pure {
    226
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    227
        }
    228
    
                                                    
                                                
    229
        function log(string memory p0, uint256 p1) internal pure {
    230
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    231
        }
    232
    
                                                    
                                                
    233
        function log(string memory p0, int256 p1) internal pure {
    234
            _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1));
    235
        }
    236
    
                                                    
                                                
    237
        function log(string memory p0, string memory p1) internal pure {
    238
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    239
        }
    240
    
                                                    
                                                
    241
        function log(string memory p0, bool p1) internal pure {
    242
            _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    243
        }
    244
    
                                                    
                                                
    245
        function log(string memory p0, address p1) internal pure {
    246
            _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    247
        }
    248
    
                                                    
                                                
    249
        function log(bool p0, uint256 p1) internal pure {
    250
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    251
        }
    252
    
                                                    
                                                
    253
        function log(bool p0, string memory p1) internal pure {
    254
            _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    255
        }
    256
    
                                                    
                                                
    257
        function log(bool p0, bool p1) internal pure {
    258
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    259
        }
    260
    
                                                    
                                                
    261
        function log(bool p0, address p1) internal pure {
    262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    263
        }
    264
    
                                                    
                                                
    265
        function log(address p0, uint256 p1) internal pure {
    266
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    267
        }
    268
    
                                                    
                                                
    269
        function log(address p0, string memory p1) internal pure {
    270
            _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    271
        }
    272
    
                                                    
                                                
    273
        function log(address p0, bool p1) internal pure {
    274
            _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    275
        }
    276
    
                                                    
                                                
    277
        function log(address p0, address p1) internal pure {
    278
            _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    279
        }
    280
    
                                                    
                                                
    281
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    282
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    283
        }
    284
    
                                                    
                                                
    285
        function log(uint256 p0, uint256 p1, string memory p2) internal pure {
    286
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    287
        }
    288
    
                                                    
                                                
    289
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    290
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    291
        }
    292
    
                                                    
                                                
    293
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    294
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    295
        }
    296
    
                                                    
                                                
    297
        function log(uint256 p0, string memory p1, uint256 p2) internal pure {
    298
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    299
        }
    300
    
                                                    
                                                
    301
        function log(uint256 p0, string memory p1, string memory p2) internal pure {
    302
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    303
        }
    304
    
                                                    
                                                
    305
        function log(uint256 p0, string memory p1, bool p2) internal pure {
    306
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    307
        }
    308
    
                                                    
                                                
    309
        function log(uint256 p0, string memory p1, address p2) internal pure {
    310
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    311
        }
    312
    
                                                    
                                                
    313
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    314
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    315
        }
    316
    
                                                    
                                                
    317
        function log(uint256 p0, bool p1, string memory p2) internal pure {
    318
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    319
        }
    320
    
                                                    
                                                
    321
        function log(uint256 p0, bool p1, bool p2) internal pure {
    322
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    323
        }
    324
    
                                                    
                                                
    325
        function log(uint256 p0, bool p1, address p2) internal pure {
    326
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    327
        }
    328
    
                                                    
                                                
    329
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    330
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    331
        }
    332
    
                                                    
                                                
    333
        function log(uint256 p0, address p1, string memory p2) internal pure {
    334
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    335
        }
    336
    
                                                    
                                                
    337
        function log(uint256 p0, address p1, bool p2) internal pure {
    338
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    339
        }
    340
    
                                                    
                                                
    341
        function log(uint256 p0, address p1, address p2) internal pure {
    342
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    343
        }
    344
    
                                                    
                                                
    345
        function log(string memory p0, uint256 p1, uint256 p2) internal pure {
    346
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    347
        }
    348
    
                                                    
                                                
    349
        function log(string memory p0, uint256 p1, string memory p2) internal pure {
    350
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    351
        }
    352
    
                                                    
                                                
    353
        function log(string memory p0, uint256 p1, bool p2) internal pure {
    354
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    355
        }
    356
    
                                                    
                                                
    357
        function log(string memory p0, uint256 p1, address p2) internal pure {
    358
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    359
        }
    360
    
                                                    
                                                
    361
        function log(string memory p0, string memory p1, uint256 p2) internal pure {
    362
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    363
        }
    364
    
                                                    
                                                
    365
        function log(string memory p0, string memory p1, string memory p2) internal pure {
    366
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    367
        }
    368
    
                                                    
                                                
    369
        function log(string memory p0, string memory p1, bool p2) internal pure {
    370
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    371
        }
    372
    
                                                    
                                                
    373
        function log(string memory p0, string memory p1, address p2) internal pure {
    374
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    375
        }
    376
    
                                                    
                                                
    377
        function log(string memory p0, bool p1, uint256 p2) internal pure {
    378
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    379
        }
    380
    
                                                    
                                                
    381
        function log(string memory p0, bool p1, string memory p2) internal pure {
    382
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    383
        }
    384
    
                                                    
                                                
    385
        function log(string memory p0, bool p1, bool p2) internal pure {
    386
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    387
        }
    388
    
                                                    
                                                
    389
        function log(string memory p0, bool p1, address p2) internal pure {
    390
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    391
        }
    392
    
                                                    
                                                
    393
        function log(string memory p0, address p1, uint256 p2) internal pure {
    394
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    395
        }
    396
    
                                                    
                                                
    397
        function log(string memory p0, address p1, string memory p2) internal pure {
    398
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    399
        }
    400
    
                                                    
                                                
    401
        function log(string memory p0, address p1, bool p2) internal pure {
    402
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    403
        }
    404
    
                                                    
                                                
    405
        function log(string memory p0, address p1, address p2) internal pure {
    406
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    407
        }
    408
    
                                                    
                                                
    409
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    410
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    411
        }
    412
    
                                                    
                                                
    413
        function log(bool p0, uint256 p1, string memory p2) internal pure {
    414
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    415
        }
    416
    
                                                    
                                                
    417
        function log(bool p0, uint256 p1, bool p2) internal pure {
    418
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    419
        }
    420
    
                                                    
                                                
    421
        function log(bool p0, uint256 p1, address p2) internal pure {
    422
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    423
        }
    424
    
                                                    
                                                
    425
        function log(bool p0, string memory p1, uint256 p2) internal pure {
    426
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    427
        }
    428
    
                                                    
                                                
    429
        function log(bool p0, string memory p1, string memory p2) internal pure {
    430
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    431
        }
    432
    
                                                    
                                                
    433
        function log(bool p0, string memory p1, bool p2) internal pure {
    434
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    435
        }
    436
    
                                                    
                                                
    437
        function log(bool p0, string memory p1, address p2) internal pure {
    438
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    439
        }
    440
    
                                                    
                                                
    441
        function log(bool p0, bool p1, uint256 p2) internal pure {
    442
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    443
        }
    444
    
                                                    
                                                
    445
        function log(bool p0, bool p1, string memory p2) internal pure {
    446
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    447
        }
    448
    
                                                    
                                                
    449
        function log(bool p0, bool p1, bool p2) internal pure {
    450
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    451
        }
    452
    
                                                    
                                                
    453
        function log(bool p0, bool p1, address p2) internal pure {
    454
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    455
        }
    456
    
                                                    
                                                
    457
        function log(bool p0, address p1, uint256 p2) internal pure {
    458
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    459
        }
    460
    
                                                    
                                                
    461
        function log(bool p0, address p1, string memory p2) internal pure {
    462
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    463
        }
    464
    
                                                    
                                                
    465
        function log(bool p0, address p1, bool p2) internal pure {
    466
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    467
        }
    468
    
                                                    
                                                
    469
        function log(bool p0, address p1, address p2) internal pure {
    470
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    471
        }
    472
    
                                                    
                                                
    473
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    474
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    475
        }
    476
    
                                                    
                                                
    477
        function log(address p0, uint256 p1, string memory p2) internal pure {
    478
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    479
        }
    480
    
                                                    
                                                
    481
        function log(address p0, uint256 p1, bool p2) internal pure {
    482
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    483
        }
    484
    
                                                    
                                                
    485
        function log(address p0, uint256 p1, address p2) internal pure {
    486
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    487
        }
    488
    
                                                    
                                                
    489
        function log(address p0, string memory p1, uint256 p2) internal pure {
    490
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    491
        }
    492
    
                                                    
                                                
    493
        function log(address p0, string memory p1, string memory p2) internal pure {
    494
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    495
        }
    496
    
                                                    
                                                
    497
        function log(address p0, string memory p1, bool p2) internal pure {
    498
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    499
        }
    500
    
                                                    
                                                
    501
        function log(address p0, string memory p1, address p2) internal pure {
    502
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    503
        }
    504
    
                                                    
                                                
    505
        function log(address p0, bool p1, uint256 p2) internal pure {
    506
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    507
        }
    508
    
                                                    
                                                
    509
        function log(address p0, bool p1, string memory p2) internal pure {
    510
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    511
        }
    512
    
                                                    
                                                
    513
        function log(address p0, bool p1, bool p2) internal pure {
    514
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    515
        }
    516
    
                                                    
                                                
    517
        function log(address p0, bool p1, address p2) internal pure {
    518
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    519
        }
    520
    
                                                    
                                                
    521
        function log(address p0, address p1, uint256 p2) internal pure {
    522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    523
        }
    524
    
                                                    
                                                
    525
        function log(address p0, address p1, string memory p2) internal pure {
    526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    527
        }
    528
    
                                                    
                                                
    529
        function log(address p0, address p1, bool p2) internal pure {
    530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    531
        }
    532
    
                                                    
                                                
    533
        function log(address p0, address p1, address p2) internal pure {
    534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    535
        }
    536
    
                                                    
                                                
    537
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    538
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    539
        }
    540
    
                                                    
                                                
    541
        function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    542
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    543
        }
    544
    
                                                    
                                                
    545
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    546
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    547
        }
    548
    
                                                    
                                                
    549
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    550
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    551
        }
    552
    
                                                    
                                                
    553
        function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    554
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    555
        }
    556
    
                                                    
                                                
    557
        function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
    558
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    559
        }
    560
    
                                                    
                                                
    561
        function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
    562
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    563
        }
    564
    
                                                    
                                                
    565
        function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
    566
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    567
        }
    568
    
                                                    
                                                
    569
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    570
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    571
        }
    572
    
                                                    
                                                
    573
        function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
    574
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    575
        }
    576
    
                                                    
                                                
    577
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    578
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    579
        }
    580
    
                                                    
                                                
    581
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    582
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    583
        }
    584
    
                                                    
                                                
    585
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    586
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    587
        }
    588
    
                                                    
                                                
    589
        function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
    590
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    591
        }
    592
    
                                                    
                                                
    593
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    594
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    595
        }
    596
    
                                                    
                                                
    597
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    598
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    599
        }
    600
    
                                                    
                                                
    601
        function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    602
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    603
        }
    604
    
                                                    
                                                
    605
        function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
    606
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    607
        }
    608
    
                                                    
                                                
    609
        function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
    610
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    611
        }
    612
    
                                                    
                                                
    613
        function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
    614
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    615
        }
    616
    
                                                    
                                                
    617
        function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
    618
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    619
        }
    620
    
                                                    
                                                
    621
        function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
    622
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    623
        }
    624
    
                                                    
                                                
    625
        function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
    626
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    627
        }
    628
    
                                                    
                                                
    629
        function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
    630
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    631
        }
    632
    
                                                    
                                                
    633
        function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
    634
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    635
        }
    636
    
                                                    
                                                
    637
        function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
    638
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    639
        }
    640
    
                                                    
                                                
    641
        function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
    642
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    643
        }
    644
    
                                                    
                                                
    645
        function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
    646
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    647
        }
    648
    
                                                    
                                                
    649
        function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
    650
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    651
        }
    652
    
                                                    
                                                
    653
        function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
    654
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    655
        }
    656
    
                                                    
                                                
    657
        function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
    658
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    659
        }
    660
    
                                                    
                                                
    661
        function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
    662
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    663
        }
    664
    
                                                    
                                                
    665
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    666
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    667
        }
    668
    
                                                    
                                                
    669
        function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
    670
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    671
        }
    672
    
                                                    
                                                
    673
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    674
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    675
        }
    676
    
                                                    
                                                
    677
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    678
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    679
        }
    680
    
                                                    
                                                
    681
        function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
    682
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    683
        }
    684
    
                                                    
                                                
    685
        function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
    686
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    687
        }
    688
    
                                                    
                                                
    689
        function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
    690
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    691
        }
    692
    
                                                    
                                                
    693
        function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
    694
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    695
        }
    696
    
                                                    
                                                
    697
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    698
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    699
        }
    700
    
                                                    
                                                
    701
        function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
    702
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    703
        }
    704
    
                                                    
                                                
    705
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    706
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    707
        }
    708
    
                                                    
                                                
    709
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    710
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    711
        }
    712
    
                                                    
                                                
    713
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    714
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    715
        }
    716
    
                                                    
                                                
    717
        function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
    718
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    719
        }
    720
    
                                                    
                                                
    721
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    722
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    723
        }
    724
    
                                                    
                                                
    725
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    726
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    727
        }
    728
    
                                                    
                                                
    729
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    730
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    731
        }
    732
    
                                                    
                                                
    733
        function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
    734
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    735
        }
    736
    
                                                    
                                                
    737
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    738
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    739
        }
    740
    
                                                    
                                                
    741
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    742
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    743
        }
    744
    
                                                    
                                                
    745
        function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
    746
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    747
        }
    748
    
                                                    
                                                
    749
        function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
    750
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    751
        }
    752
    
                                                    
                                                
    753
        function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
    754
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    755
        }
    756
    
                                                    
                                                
    757
        function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
    758
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    759
        }
    760
    
                                                    
                                                
    761
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    762
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    763
        }
    764
    
                                                    
                                                
    765
        function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
    766
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    767
        }
    768
    
                                                    
                                                
    769
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    770
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    771
        }
    772
    
                                                    
                                                
    773
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    774
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    775
        }
    776
    
                                                    
                                                
    777
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    778
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    779
        }
    780
    
                                                    
                                                
    781
        function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
    782
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    783
        }
    784
    
                                                    
                                                
    785
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    786
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    787
        }
    788
    
                                                    
                                                
    789
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    790
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    791
        }
    792
    
                                                    
                                                
    793
        function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    794
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    795
        }
    796
    
                                                    
                                                
    797
        function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    798
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    799
        }
    800
    
                                                    
                                                
    801
        function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
    802
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    803
        }
    804
    
                                                    
                                                
    805
        function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
    806
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    807
        }
    808
    
                                                    
                                                
    809
        function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    810
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    811
        }
    812
    
                                                    
                                                
    813
        function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
    814
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    815
        }
    816
    
                                                    
                                                
    817
        function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
    818
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    819
        }
    820
    
                                                    
                                                
    821
        function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
    822
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    823
        }
    824
    
                                                    
                                                
    825
        function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
    826
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    827
        }
    828
    
                                                    
                                                
    829
        function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
    830
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    831
        }
    832
    
                                                    
                                                
    833
        function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
    834
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    835
        }
    836
    
                                                    
                                                
    837
        function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
    838
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    839
        }
    840
    
                                                    
                                                
    841
        function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
    842
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    843
        }
    844
    
                                                    
                                                
    845
        function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
    846
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    847
        }
    848
    
                                                    
                                                
    849
        function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
    850
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    851
        }
    852
    
                                                    
                                                
    853
        function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
    854
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    855
        }
    856
    
                                                    
                                                
    857
        function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    858
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    859
        }
    860
    
                                                    
                                                
    861
        function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
    862
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    863
        }
    864
    
                                                    
                                                
    865
        function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
    866
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    867
        }
    868
    
                                                    
                                                
    869
        function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
    870
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    871
        }
    872
    
                                                    
                                                
    873
        function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
    874
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    875
        }
    876
    
                                                    
                                                
    877
        function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
    878
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    879
        }
    880
    
                                                    
                                                
    881
        function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
    882
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    883
        }
    884
    
                                                    
                                                
    885
        function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
    886
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    887
        }
    888
    
                                                    
                                                
    889
        function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
    890
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    891
        }
    892
    
                                                    
                                                
    893
        function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
    894
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    895
        }
    896
    
                                                    
                                                
    897
        function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
    898
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    899
        }
    900
    
                                                    
                                                
    901
        function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
    902
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    903
        }
    904
    
                                                    
                                                
    905
        function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
    906
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    907
        }
    908
    
                                                    
                                                
    909
        function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
    910
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    911
        }
    912
    
                                                    
                                                
    913
        function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
    914
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    915
        }
    916
    
                                                    
                                                
    917
        function log(string memory p0, string memory p1, address p2, address p3) internal pure {
    918
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    919
        }
    920
    
                                                    
                                                
    921
        function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
    922
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    923
        }
    924
    
                                                    
                                                
    925
        function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
    926
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    927
        }
    928
    
                                                    
                                                
    929
        function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
    930
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    931
        }
    932
    
                                                    
                                                
    933
        function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
    934
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    935
        }
    936
    
                                                    
                                                
    937
        function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
    938
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    939
        }
    940
    
                                                    
                                                
    941
        function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
    942
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    943
        }
    944
    
                                                    
                                                
    945
        function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
    946
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    947
        }
    948
    
                                                    
                                                
    949
        function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
    950
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    951
        }
    952
    
                                                    
                                                
    953
        function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
    954
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    955
        }
    956
    
                                                    
                                                
    957
        function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
    958
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    959
        }
    960
    
                                                    
                                                
    961
        function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
    962
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    963
        }
    964
    
                                                    
                                                
    965
        function log(string memory p0, bool p1, bool p2, address p3) internal pure {
    966
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    967
        }
    968
    
                                                    
                                                
    969
        function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
    970
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    971
        }
    972
    
                                                    
                                                
    973
        function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
    974
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    975
        }
    976
    
                                                    
                                                
    977
        function log(string memory p0, bool p1, address p2, bool p3) internal pure {
    978
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    979
        }
    980
    
                                                    
                                                
    981
        function log(string memory p0, bool p1, address p2, address p3) internal pure {
    982
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    983
        }
    984
    
                                                    
                                                
    985
        function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
    986
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    987
        }
    988
    
                                                    
                                                
    989
        function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
    990
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    991
        }
    992
    
                                                    
                                                
    993
        function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
    994
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    995
        }
    996
    
                                                    
                                                
    997
        function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
    998
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    999
        }
    1000
    
                                                    
                                                
    1001
        function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
    1002
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    1003
        }
    1004
    
                                                    
                                                
    1005
        function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
    1006
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    1007
        }
    1008
    
                                                    
                                                
    1009
        function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
    1010
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    1011
        }
    1012
    
                                                    
                                                
    1013
        function log(string memory p0, address p1, string memory p2, address p3) internal pure {
    1014
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    1015
        }
    1016
    
                                                    
                                                
    1017
        function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
    1018
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    1019
        }
    1020
    
                                                    
                                                
    1021
        function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
    1022
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    1023
        }
    1024
    
                                                    
                                                
    1025
        function log(string memory p0, address p1, bool p2, bool p3) internal pure {
    1026
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    1027
        }
    1028
    
                                                    
                                                
    1029
        function log(string memory p0, address p1, bool p2, address p3) internal pure {
    1030
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    1031
        }
    1032
    
                                                    
                                                
    1033
        function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
    1034
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    1035
        }
    1036
    
                                                    
                                                
    1037
        function log(string memory p0, address p1, address p2, string memory p3) internal pure {
    1038
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    1039
        }
    1040
    
                                                    
                                                
    1041
        function log(string memory p0, address p1, address p2, bool p3) internal pure {
    1042
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    1043
        }
    1044
    
                                                    
                                                
    1045
        function log(string memory p0, address p1, address p2, address p3) internal pure {
    1046
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    1047
        }
    1048
    
                                                    
                                                
    1049
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1050
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    1051
        }
    1052
    
                                                    
                                                
    1053
        function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1054
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    1055
        }
    1056
    
                                                    
                                                
    1057
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1058
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    1059
        }
    1060
    
                                                    
                                                
    1061
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    1062
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    1063
        }
    1064
    
                                                    
                                                
    1065
        function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1066
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    1067
        }
    1068
    
                                                    
                                                
    1069
        function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1070
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    1071
        }
    1072
    
                                                    
                                                
    1073
        function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
    1074
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    1075
        }
    1076
    
                                                    
                                                
    1077
        function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
    1078
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    1079
        }
    1080
    
                                                    
                                                
    1081
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1082
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    1083
        }
    1084
    
                                                    
                                                
    1085
        function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
    1086
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    1087
        }
    1088
    
                                                    
                                                
    1089
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    1090
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    1091
        }
    1092
    
                                                    
                                                
    1093
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    1094
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    1095
        }
    1096
    
                                                    
                                                
    1097
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    1098
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    1099
        }
    1100
    
                                                    
                                                
    1101
        function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
    1102
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    1103
        }
    1104
    
                                                    
                                                
    1105
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    1106
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    1107
        }
    1108
    
                                                    
                                                
    1109
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    1110
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    1111
        }
    1112
    
                                                    
                                                
    1113
        function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1114
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    1115
        }
    1116
    
                                                    
                                                
    1117
        function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1118
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    1119
        }
    1120
    
                                                    
                                                
    1121
        function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
    1122
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    1123
        }
    1124
    
                                                    
                                                
    1125
        function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
    1126
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    1127
        }
    1128
    
                                                    
                                                
    1129
        function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1130
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    1131
        }
    1132
    
                                                    
                                                
    1133
        function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
    1134
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    1135
        }
    1136
    
                                                    
                                                
    1137
        function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
    1138
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    1139
        }
    1140
    
                                                    
                                                
    1141
        function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
    1142
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    1143
        }
    1144
    
                                                    
                                                
    1145
        function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
    1146
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    1147
        }
    1148
    
                                                    
                                                
    1149
        function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
    1150
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    1151
        }
    1152
    
                                                    
                                                
    1153
        function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
    1154
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    1155
        }
    1156
    
                                                    
                                                
    1157
        function log(bool p0, string memory p1, bool p2, address p3) internal pure {
    1158
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    1159
        }
    1160
    
                                                    
                                                
    1161
        function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
    1162
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    1163
        }
    1164
    
                                                    
                                                
    1165
        function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
    1166
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    1167
        }
    1168
    
                                                    
                                                
    1169
        function log(bool p0, string memory p1, address p2, bool p3) internal pure {
    1170
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    1171
        }
    1172
    
                                                    
                                                
    1173
        function log(bool p0, string memory p1, address p2, address p3) internal pure {
    1174
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    1175
        }
    1176
    
                                                    
                                                
    1177
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1178
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    1179
        }
    1180
    
                                                    
                                                
    1181
        function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
    1182
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    1183
        }
    1184
    
                                                    
                                                
    1185
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    1186
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    1187
        }
    1188
    
                                                    
                                                
    1189
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    1190
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    1191
        }
    1192
    
                                                    
                                                
    1193
        function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
    1194
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    1195
        }
    1196
    
                                                    
                                                
    1197
        function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
    1198
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    1199
        }
    1200
    
                                                    
                                                
    1201
        function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
    1202
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    1203
        }
    1204
    
                                                    
                                                
    1205
        function log(bool p0, bool p1, string memory p2, address p3) internal pure {
    1206
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    1207
        }
    1208
    
                                                    
                                                
    1209
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    1210
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    1211
        }
    1212
    
                                                    
                                                
    1213
        function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
    1214
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    1215
        }
    1216
    
                                                    
                                                
    1217
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    1218
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    1219
        }
    1220
    
                                                    
                                                
    1221
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    1222
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    1223
        }
    1224
    
                                                    
                                                
    1225
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    1226
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    1227
        }
    1228
    
                                                    
                                                
    1229
        function log(bool p0, bool p1, address p2, string memory p3) internal pure {
    1230
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    1231
        }
    1232
    
                                                    
                                                
    1233
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    1234
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    1235
        }
    1236
    
                                                    
                                                
    1237
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    1238
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    1239
        }
    1240
    
                                                    
                                                
    1241
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    1242
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    1243
        }
    1244
    
                                                    
                                                
    1245
        function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
    1246
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    1247
        }
    1248
    
                                                    
                                                
    1249
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    1250
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    1251
        }
    1252
    
                                                    
                                                
    1253
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    1254
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    1255
        }
    1256
    
                                                    
                                                
    1257
        function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
    1258
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    1259
        }
    1260
    
                                                    
                                                
    1261
        function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
    1262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    1263
        }
    1264
    
                                                    
                                                
    1265
        function log(bool p0, address p1, string memory p2, bool p3) internal pure {
    1266
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    1267
        }
    1268
    
                                                    
                                                
    1269
        function log(bool p0, address p1, string memory p2, address p3) internal pure {
    1270
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    1271
        }
    1272
    
                                                    
                                                
    1273
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    1274
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    1275
        }
    1276
    
                                                    
                                                
    1277
        function log(bool p0, address p1, bool p2, string memory p3) internal pure {
    1278
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    1279
        }
    1280
    
                                                    
                                                
    1281
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    1282
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    1283
        }
    1284
    
                                                    
                                                
    1285
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    1286
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    1287
        }
    1288
    
                                                    
                                                
    1289
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    1290
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    1291
        }
    1292
    
                                                    
                                                
    1293
        function log(bool p0, address p1, address p2, string memory p3) internal pure {
    1294
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    1295
        }
    1296
    
                                                    
                                                
    1297
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    1298
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    1299
        }
    1300
    
                                                    
                                                
    1301
        function log(bool p0, address p1, address p2, address p3) internal pure {
    1302
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    1303
        }
    1304
    
                                                    
                                                
    1305
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1306
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    1307
        }
    1308
    
                                                    
                                                
    1309
        function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1310
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    1311
        }
    1312
    
                                                    
                                                
    1313
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1314
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    1315
        }
    1316
    
                                                    
                                                
    1317
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    1318
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    1319
        }
    1320
    
                                                    
                                                
    1321
        function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1322
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    1323
        }
    1324
    
                                                    
                                                
    1325
        function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1326
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    1327
        }
    1328
    
                                                    
                                                
    1329
        function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
    1330
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    1331
        }
    1332
    
                                                    
                                                
    1333
        function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
    1334
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    1335
        }
    1336
    
                                                    
                                                
    1337
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1338
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    1339
        }
    1340
    
                                                    
                                                
    1341
        function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
    1342
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    1343
        }
    1344
    
                                                    
                                                
    1345
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    1346
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    1347
        }
    1348
    
                                                    
                                                
    1349
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    1350
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    1351
        }
    1352
    
                                                    
                                                
    1353
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    1354
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    1355
        }
    1356
    
                                                    
                                                
    1357
        function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
    1358
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    1359
        }
    1360
    
                                                    
                                                
    1361
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    1362
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    1363
        }
    1364
    
                                                    
                                                
    1365
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    1366
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    1367
        }
    1368
    
                                                    
                                                
    1369
        function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1370
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    1371
        }
    1372
    
                                                    
                                                
    1373
        function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1374
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    1375
        }
    1376
    
                                                    
                                                
    1377
        function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
    1378
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    1379
        }
    1380
    
                                                    
                                                
    1381
        function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
    1382
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    1383
        }
    1384
    
                                                    
                                                
    1385
        function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1386
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    1387
        }
    1388
    
                                                    
                                                
    1389
        function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
    1390
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    1391
        }
    1392
    
                                                    
                                                
    1393
        function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
    1394
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    1395
        }
    1396
    
                                                    
                                                
    1397
        function log(address p0, string memory p1, string memory p2, address p3) internal pure {
    1398
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    1399
        }
    1400
    
                                                    
                                                
    1401
        function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
    1402
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    1403
        }
    1404
    
                                                    
                                                
    1405
        function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
    1406
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    1407
        }
    1408
    
                                                    
                                                
    1409
        function log(address p0, string memory p1, bool p2, bool p3) internal pure {
    1410
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    1411
        }
    1412
    
                                                    
                                                
    1413
        function log(address p0, string memory p1, bool p2, address p3) internal pure {
    1414
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    1415
        }
    1416
    
                                                    
                                                
    1417
        function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
    1418
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    1419
        }
    1420
    
                                                    
                                                
    1421
        function log(address p0, string memory p1, address p2, string memory p3) internal pure {
    1422
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    1423
        }
    1424
    
                                                    
                                                
    1425
        function log(address p0, string memory p1, address p2, bool p3) internal pure {
    1426
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    1427
        }
    1428
    
                                                    
                                                
    1429
        function log(address p0, string memory p1, address p2, address p3) internal pure {
    1430
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    1431
        }
    1432
    
                                                    
                                                
    1433
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1434
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    1435
        }
    1436
    
                                                    
                                                
    1437
        function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
    1438
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    1439
        }
    1440
    
                                                    
                                                
    1441
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    1442
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    1443
        }
    1444
    
                                                    
                                                
    1445
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    1446
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    1447
        }
    1448
    
                                                    
                                                
    1449
        function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
    1450
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    1451
        }
    1452
    
                                                    
                                                
    1453
        function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
    1454
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    1455
        }
    1456
    
                                                    
                                                
    1457
        function log(address p0, bool p1, string memory p2, bool p3) internal pure {
    1458
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    1459
        }
    1460
    
                                                    
                                                
    1461
        function log(address p0, bool p1, string memory p2, address p3) internal pure {
    1462
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    1463
        }
    1464
    
                                                    
                                                
    1465
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    1466
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    1467
        }
    1468
    
                                                    
                                                
    1469
        function log(address p0, bool p1, bool p2, string memory p3) internal pure {
    1470
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    1471
        }
    1472
    
                                                    
                                                
    1473
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    1474
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    1475
        }
    1476
    
                                                    
                                                
    1477
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    1478
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    1479
        }
    1480
    
                                                    
                                                
    1481
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    1482
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    1483
        }
    1484
    
                                                    
                                                
    1485
        function log(address p0, bool p1, address p2, string memory p3) internal pure {
    1486
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    1487
        }
    1488
    
                                                    
                                                
    1489
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    1490
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    1491
        }
    1492
    
                                                    
                                                
    1493
        function log(address p0, bool p1, address p2, address p3) internal pure {
    1494
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    1495
        }
    1496
    
                                                    
                                                
    1497
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    1498
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    1499
        }
    1500
    
                                                    
                                                
    1501
        function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
    1502
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    1503
        }
    1504
    
                                                    
                                                
    1505
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    1506
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    1507
        }
    1508
    
                                                    
                                                
    1509
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    1510
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    1511
        }
    1512
    
                                                    
                                                
    1513
        function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
    1514
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    1515
        }
    1516
    
                                                    
                                                
    1517
        function log(address p0, address p1, string memory p2, string memory p3) internal pure {
    1518
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    1519
        }
    1520
    
                                                    
                                                
    1521
        function log(address p0, address p1, string memory p2, bool p3) internal pure {
    1522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    1523
        }
    1524
    
                                                    
                                                
    1525
        function log(address p0, address p1, string memory p2, address p3) internal pure {
    1526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    1527
        }
    1528
    
                                                    
                                                
    1529
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    1530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    1531
        }
    1532
    
                                                    
                                                
    1533
        function log(address p0, address p1, bool p2, string memory p3) internal pure {
    1534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    1535
        }
    1536
    
                                                    
                                                
    1537
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    1538
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    1539
        }
    1540
    
                                                    
                                                
    1541
        function log(address p0, address p1, bool p2, address p3) internal pure {
    1542
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    1543
        }
    1544
    
                                                    
                                                
    1545
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    1546
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    1547
        }
    1548
    
                                                    
                                                
    1549
        function log(address p0, address p1, address p2, string memory p3) internal pure {
    1550
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    1551
        }
    1552
    
                                                    
                                                
    1553
        function log(address p0, address p1, address p2, bool p3) internal pure {
    1554
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    1555
        }
    1556
    
                                                    
                                                
    1557
        function log(address p0, address p1, address p2, address p3) internal pure {
    1558
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    1559
        }
    1560
    }
    1561
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/console2.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    
                                                    
                                                
    4
    import {console as console2} from "./console.sol";
    5
    
                                                    
                                                
    0.0% lib/openzeppelin-contracts/lib/forge-std/src/interfaces/IMulticall3.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    pragma experimental ABIEncoderV2;
    5
    
                                                    
                                                
    6
    interface IMulticall3 {
    7
        struct Call {
    8
            address target;
    9
            bytes callData;
    10
        }
    11
    
                                                    
                                                
    12
        struct Call3 {
    13
            address target;
    14
            bool allowFailure;
    15
            bytes callData;
    16
        }
    17
    
                                                    
                                                
    18
        struct Call3Value {
    19
            address target;
    20
            bool allowFailure;
    21
            uint256 value;
    22
            bytes callData;
    23
        }
    24
    
                                                    
                                                
    25
        struct Result {
    26
            bool success;
    27
            bytes returnData;
    28
        }
    29
    
                                                    
                                                
    30
        function aggregate(Call[] calldata calls)
    31
            external
    32
            payable
    33
            returns (uint256 blockNumber, bytes[] memory returnData);
    34
    
                                                    
                                                
    35
        function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
    36
    
                                                    
                                                
    37
        function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
    38
    
                                                    
                                                
    39
        function blockAndAggregate(Call[] calldata calls)
    40
            external
    41
            payable
    42
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    43
    
                                                    
                                                
    44
        function getBasefee() external view returns (uint256 basefee);
    45
    
                                                    
                                                
    46
        function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
    47
    
                                                    
                                                
    48
        function getBlockNumber() external view returns (uint256 blockNumber);
    49
    
                                                    
                                                
    50
        function getChainId() external view returns (uint256 chainid);
    51
    
                                                    
                                                
    52
        function getCurrentBlockCoinbase() external view returns (address coinbase);
    53
    
                                                    
                                                
    54
        function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
    55
    
                                                    
                                                
    56
        function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
    57
    
                                                    
                                                
    58
        function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
    59
    
                                                    
                                                
    60
        function getEthBalance(address addr) external view returns (uint256 balance);
    61
    
                                                    
                                                
    62
        function getLastBlockHash() external view returns (bytes32 blockHash);
    63
    
                                                    
                                                
    64
        function tryAggregate(bool requireSuccess, Call[] calldata calls)
    65
            external
    66
            payable
    67
            returns (Result[] memory returnData);
    68
    
                                                    
                                                
    69
        function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
    70
            external
    71
            payable
    72
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    73
    }
    74
    
                                                    
                                                
    100.0% lib/openzeppelin-contracts/lib/forge-std/src/safeconsole.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    
                                                    
                                                
    4
    /// @author philogy <https://github.com/philogy>
    5
    /// @dev Code generated automatically by script.
    6
    ✓ 15
    library safeconsole {
    7
        uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;
    8
    
                                                    
                                                
    9
        // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)
    10
        // for the view-to-pure log trick.
    11
        function _sendLogPayload(uint256 offset, uint256 size) private pure {
    12
            function(uint256, uint256) internal view fnIn = _sendLogPayloadView;
    13
            function(uint256, uint256) internal pure pureSendLogPayload;
    14
            /// @solidity memory-safe-assembly
    15
            assembly {
    16
                pureSendLogPayload := fnIn
    17
            }
    18
            pureSendLogPayload(offset, size);
    19
        }
    20
    
                                                    
                                                
    21
        function _sendLogPayloadView(uint256 offset, uint256 size) private view {
    22
            /// @solidity memory-safe-assembly
    23
            assembly {
    24
                pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))
    25
            }
    26
        }
    27
    
                                                    
                                                
    28
        function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {
    29
            function(uint256, uint256, uint256) internal view fnIn = _memcopyView;
    30
            function(uint256, uint256, uint256) internal pure pureMemcopy;
    31
            /// @solidity memory-safe-assembly
    32
            assembly {
    33
                pureMemcopy := fnIn
    34
            }
    35
            pureMemcopy(fromOffset, toOffset, length);
    36
        }
    37
    
                                                    
                                                
    38
        function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {
    39
            /// @solidity memory-safe-assembly
    40
            assembly {
    41
                pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))
    42
            }
    43
        }
    44
    
                                                    
                                                
    45
        function logMemory(uint256 offset, uint256 length) internal pure {
    46
            if (offset >= 0x60) {
    47
                // Sufficient memory before slice to prepare call header.
    48
                bytes32 m0;
    49
                bytes32 m1;
    50
                bytes32 m2;
    51
                /// @solidity memory-safe-assembly
    52
                assembly {
    53
                    m0 := mload(sub(offset, 0x60))
    54
                    m1 := mload(sub(offset, 0x40))
    55
                    m2 := mload(sub(offset, 0x20))
    56
                    // Selector of `log(bytes)`.
    57
                    mstore(sub(offset, 0x60), 0x0be77f56)
    58
                    mstore(sub(offset, 0x40), 0x20)
    59
                    mstore(sub(offset, 0x20), length)
    60
                }
    61
                _sendLogPayload(offset - 0x44, length + 0x44);
    62
                /// @solidity memory-safe-assembly
    63
                assembly {
    64
                    mstore(sub(offset, 0x60), m0)
    65
                    mstore(sub(offset, 0x40), m1)
    66
                    mstore(sub(offset, 0x20), m2)
    67
                }
    68
            } else {
    69
                // Insufficient space, so copy slice forward, add header and reverse.
    70
                bytes32 m0;
    71
                bytes32 m1;
    72
                bytes32 m2;
    73
                uint256 endOffset = offset + length;
    74
                /// @solidity memory-safe-assembly
    75
                assembly {
    76
                    m0 := mload(add(endOffset, 0x00))
    77
                    m1 := mload(add(endOffset, 0x20))
    78
                    m2 := mload(add(endOffset, 0x40))
    79
                }
    80
                _memcopy(offset, offset + 0x60, length);
    81
                /// @solidity memory-safe-assembly
    82
                assembly {
    83
                    // Selector of `log(bytes)`.
    84
                    mstore(add(offset, 0x00), 0x0be77f56)
    85
                    mstore(add(offset, 0x20), 0x20)
    86
                    mstore(add(offset, 0x40), length)
    87
                }
    88
                _sendLogPayload(offset + 0x1c, length + 0x44);
    89
                _memcopy(offset + 0x60, offset, length);
    90
                /// @solidity memory-safe-assembly
    91
                assembly {
    92
                    mstore(add(endOffset, 0x00), m0)
    93
                    mstore(add(endOffset, 0x20), m1)
    94
                    mstore(add(endOffset, 0x40), m2)
    95
                }
    96
            }
    97
        }
    98
    
                                                    
                                                
    99
        function log(address p0) internal pure {
    100
            bytes32 m0;
    101
            bytes32 m1;
    102
            /// @solidity memory-safe-assembly
    103
            assembly {
    104
                m0 := mload(0x00)
    105
                m1 := mload(0x20)
    106
                // Selector of `log(address)`.
    107
                mstore(0x00, 0x2c2ecbc2)
    108
                mstore(0x20, p0)
    109
            }
    110
            _sendLogPayload(0x1c, 0x24);
    111
            /// @solidity memory-safe-assembly
    112
            assembly {
    113
                mstore(0x00, m0)
    114
                mstore(0x20, m1)
    115
            }
    116
        }
    117
    
                                                    
                                                
    118
        function log(bool p0) internal pure {
    119
            bytes32 m0;
    120
            bytes32 m1;
    121
            /// @solidity memory-safe-assembly
    122
            assembly {
    123
                m0 := mload(0x00)
    124
                m1 := mload(0x20)
    125
                // Selector of `log(bool)`.
    126
                mstore(0x00, 0x32458eed)
    127
                mstore(0x20, p0)
    128
            }
    129
            _sendLogPayload(0x1c, 0x24);
    130
            /// @solidity memory-safe-assembly
    131
            assembly {
    132
                mstore(0x00, m0)
    133
                mstore(0x20, m1)
    134
            }
    135
        }
    136
    
                                                    
                                                
    137
        function log(uint256 p0) internal pure {
    138
            bytes32 m0;
    139
            bytes32 m1;
    140
            /// @solidity memory-safe-assembly
    141
            assembly {
    142
                m0 := mload(0x00)
    143
                m1 := mload(0x20)
    144
                // Selector of `log(uint256)`.
    145
                mstore(0x00, 0xf82c50f1)
    146
                mstore(0x20, p0)
    147
            }
    148
            _sendLogPayload(0x1c, 0x24);
    149
            /// @solidity memory-safe-assembly
    150
            assembly {
    151
                mstore(0x00, m0)
    152
                mstore(0x20, m1)
    153
            }
    154
        }
    155
    
                                                    
                                                
    156
        function log(bytes32 p0) internal pure {
    157
            bytes32 m0;
    158
            bytes32 m1;
    159
            bytes32 m2;
    160
            bytes32 m3;
    161
            /// @solidity memory-safe-assembly
    162
            assembly {
    163
                function writeString(pos, w) {
    164
                    let length := 0
    165
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    166
                    mstore(pos, length)
    167
                    let shift := sub(256, shl(3, length))
    168
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    169
                }
    170
                m0 := mload(0x00)
    171
                m1 := mload(0x20)
    172
                m2 := mload(0x40)
    173
                m3 := mload(0x60)
    174
                // Selector of `log(string)`.
    175
                mstore(0x00, 0x41304fac)
    176
                mstore(0x20, 0x20)
    177
                writeString(0x40, p0)
    178
            }
    179
            _sendLogPayload(0x1c, 0x64);
    180
            /// @solidity memory-safe-assembly
    181
            assembly {
    182
                mstore(0x00, m0)
    183
                mstore(0x20, m1)
    184
                mstore(0x40, m2)
    185
                mstore(0x60, m3)
    186
            }
    187
        }
    188
    
                                                    
                                                
    189
        function log(address p0, address p1) internal pure {
    190
            bytes32 m0;
    191
            bytes32 m1;
    192
            bytes32 m2;
    193
            /// @solidity memory-safe-assembly
    194
            assembly {
    195
                m0 := mload(0x00)
    196
                m1 := mload(0x20)
    197
                m2 := mload(0x40)
    198
                // Selector of `log(address,address)`.
    199
                mstore(0x00, 0xdaf0d4aa)
    200
                mstore(0x20, p0)
    201
                mstore(0x40, p1)
    202
            }
    203
            _sendLogPayload(0x1c, 0x44);
    204
            /// @solidity memory-safe-assembly
    205
            assembly {
    206
                mstore(0x00, m0)
    207
                mstore(0x20, m1)
    208
                mstore(0x40, m2)
    209
            }
    210
        }
    211
    
                                                    
                                                
    212
        function log(address p0, bool p1) internal pure {
    213
            bytes32 m0;
    214
            bytes32 m1;
    215
            bytes32 m2;
    216
            /// @solidity memory-safe-assembly
    217
            assembly {
    218
                m0 := mload(0x00)
    219
                m1 := mload(0x20)
    220
                m2 := mload(0x40)
    221
                // Selector of `log(address,bool)`.
    222
                mstore(0x00, 0x75b605d3)
    223
                mstore(0x20, p0)
    224
                mstore(0x40, p1)
    225
            }
    226
            _sendLogPayload(0x1c, 0x44);
    227
            /// @solidity memory-safe-assembly
    228
            assembly {
    229
                mstore(0x00, m0)
    230
                mstore(0x20, m1)
    231
                mstore(0x40, m2)
    232
            }
    233
        }
    234
    
                                                    
                                                
    235
        function log(address p0, uint256 p1) internal pure {
    236
            bytes32 m0;
    237
            bytes32 m1;
    238
            bytes32 m2;
    239
            /// @solidity memory-safe-assembly
    240
            assembly {
    241
                m0 := mload(0x00)
    242
                m1 := mload(0x20)
    243
                m2 := mload(0x40)
    244
                // Selector of `log(address,uint256)`.
    245
                mstore(0x00, 0x8309e8a8)
    246
                mstore(0x20, p0)
    247
                mstore(0x40, p1)
    248
            }
    249
            _sendLogPayload(0x1c, 0x44);
    250
            /// @solidity memory-safe-assembly
    251
            assembly {
    252
                mstore(0x00, m0)
    253
                mstore(0x20, m1)
    254
                mstore(0x40, m2)
    255
            }
    256
        }
    257
    
                                                    
                                                
    258
        function log(address p0, bytes32 p1) internal pure {
    259
            bytes32 m0;
    260
            bytes32 m1;
    261
            bytes32 m2;
    262
            bytes32 m3;
    263
            bytes32 m4;
    264
            /// @solidity memory-safe-assembly
    265
            assembly {
    266
                function writeString(pos, w) {
    267
                    let length := 0
    268
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    269
                    mstore(pos, length)
    270
                    let shift := sub(256, shl(3, length))
    271
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    272
                }
    273
                m0 := mload(0x00)
    274
                m1 := mload(0x20)
    275
                m2 := mload(0x40)
    276
                m3 := mload(0x60)
    277
                m4 := mload(0x80)
    278
                // Selector of `log(address,string)`.
    279
                mstore(0x00, 0x759f86bb)
    280
                mstore(0x20, p0)
    281
                mstore(0x40, 0x40)
    282
                writeString(0x60, p1)
    283
            }
    284
            _sendLogPayload(0x1c, 0x84);
    285
            /// @solidity memory-safe-assembly
    286
            assembly {
    287
                mstore(0x00, m0)
    288
                mstore(0x20, m1)
    289
                mstore(0x40, m2)
    290
                mstore(0x60, m3)
    291
                mstore(0x80, m4)
    292
            }
    293
        }
    294
    
                                                    
                                                
    295
        function log(bool p0, address p1) internal pure {
    296
            bytes32 m0;
    297
            bytes32 m1;
    298
            bytes32 m2;
    299
            /// @solidity memory-safe-assembly
    300
            assembly {
    301
                m0 := mload(0x00)
    302
                m1 := mload(0x20)
    303
                m2 := mload(0x40)
    304
                // Selector of `log(bool,address)`.
    305
                mstore(0x00, 0x853c4849)
    306
                mstore(0x20, p0)
    307
                mstore(0x40, p1)
    308
            }
    309
            _sendLogPayload(0x1c, 0x44);
    310
            /// @solidity memory-safe-assembly
    311
            assembly {
    312
                mstore(0x00, m0)
    313
                mstore(0x20, m1)
    314
                mstore(0x40, m2)
    315
            }
    316
        }
    317
    
                                                    
                                                
    318
        function log(bool p0, bool p1) internal pure {
    319
            bytes32 m0;
    320
            bytes32 m1;
    321
            bytes32 m2;
    322
            /// @solidity memory-safe-assembly
    323
            assembly {
    324
                m0 := mload(0x00)
    325
                m1 := mload(0x20)
    326
                m2 := mload(0x40)
    327
                // Selector of `log(bool,bool)`.
    328
                mstore(0x00, 0x2a110e83)
    329
                mstore(0x20, p0)
    330
                mstore(0x40, p1)
    331
            }
    332
            _sendLogPayload(0x1c, 0x44);
    333
            /// @solidity memory-safe-assembly
    334
            assembly {
    335
                mstore(0x00, m0)
    336
                mstore(0x20, m1)
    337
                mstore(0x40, m2)
    338
            }
    339
        }
    340
    
                                                    
                                                
    341
        function log(bool p0, uint256 p1) internal pure {
    342
            bytes32 m0;
    343
            bytes32 m1;
    344
            bytes32 m2;
    345
            /// @solidity memory-safe-assembly
    346
            assembly {
    347
                m0 := mload(0x00)
    348
                m1 := mload(0x20)
    349
                m2 := mload(0x40)
    350
                // Selector of `log(bool,uint256)`.
    351
                mstore(0x00, 0x399174d3)
    352
                mstore(0x20, p0)
    353
                mstore(0x40, p1)
    354
            }
    355
            _sendLogPayload(0x1c, 0x44);
    356
            /// @solidity memory-safe-assembly
    357
            assembly {
    358
                mstore(0x00, m0)
    359
                mstore(0x20, m1)
    360
                mstore(0x40, m2)
    361
            }
    362
        }
    363
    
                                                    
                                                
    364
        function log(bool p0, bytes32 p1) internal pure {
    365
            bytes32 m0;
    366
            bytes32 m1;
    367
            bytes32 m2;
    368
            bytes32 m3;
    369
            bytes32 m4;
    370
            /// @solidity memory-safe-assembly
    371
            assembly {
    372
                function writeString(pos, w) {
    373
                    let length := 0
    374
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    375
                    mstore(pos, length)
    376
                    let shift := sub(256, shl(3, length))
    377
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    378
                }
    379
                m0 := mload(0x00)
    380
                m1 := mload(0x20)
    381
                m2 := mload(0x40)
    382
                m3 := mload(0x60)
    383
                m4 := mload(0x80)
    384
                // Selector of `log(bool,string)`.
    385
                mstore(0x00, 0x8feac525)
    386
                mstore(0x20, p0)
    387
                mstore(0x40, 0x40)
    388
                writeString(0x60, p1)
    389
            }
    390
            _sendLogPayload(0x1c, 0x84);
    391
            /// @solidity memory-safe-assembly
    392
            assembly {
    393
                mstore(0x00, m0)
    394
                mstore(0x20, m1)
    395
                mstore(0x40, m2)
    396
                mstore(0x60, m3)
    397
                mstore(0x80, m4)
    398
            }
    399
        }
    400
    
                                                    
                                                
    401
        function log(uint256 p0, address p1) internal pure {
    402
            bytes32 m0;
    403
            bytes32 m1;
    404
            bytes32 m2;
    405
            /// @solidity memory-safe-assembly
    406
            assembly {
    407
                m0 := mload(0x00)
    408
                m1 := mload(0x20)
    409
                m2 := mload(0x40)
    410
                // Selector of `log(uint256,address)`.
    411
                mstore(0x00, 0x69276c86)
    412
                mstore(0x20, p0)
    413
                mstore(0x40, p1)
    414
            }
    415
            _sendLogPayload(0x1c, 0x44);
    416
            /// @solidity memory-safe-assembly
    417
            assembly {
    418
                mstore(0x00, m0)
    419
                mstore(0x20, m1)
    420
                mstore(0x40, m2)
    421
            }
    422
        }
    423
    
                                                    
                                                
    424
        function log(uint256 p0, bool p1) internal pure {
    425
            bytes32 m0;
    426
            bytes32 m1;
    427
            bytes32 m2;
    428
            /// @solidity memory-safe-assembly
    429
            assembly {
    430
                m0 := mload(0x00)
    431
                m1 := mload(0x20)
    432
                m2 := mload(0x40)
    433
                // Selector of `log(uint256,bool)`.
    434
                mstore(0x00, 0x1c9d7eb3)
    435
                mstore(0x20, p0)
    436
                mstore(0x40, p1)
    437
            }
    438
            _sendLogPayload(0x1c, 0x44);
    439
            /// @solidity memory-safe-assembly
    440
            assembly {
    441
                mstore(0x00, m0)
    442
                mstore(0x20, m1)
    443
                mstore(0x40, m2)
    444
            }
    445
        }
    446
    
                                                    
                                                
    447
        function log(uint256 p0, uint256 p1) internal pure {
    448
            bytes32 m0;
    449
            bytes32 m1;
    450
            bytes32 m2;
    451
            /// @solidity memory-safe-assembly
    452
            assembly {
    453
                m0 := mload(0x00)
    454
                m1 := mload(0x20)
    455
                m2 := mload(0x40)
    456
                // Selector of `log(uint256,uint256)`.
    457
                mstore(0x00, 0xf666715a)
    458
                mstore(0x20, p0)
    459
                mstore(0x40, p1)
    460
            }
    461
            _sendLogPayload(0x1c, 0x44);
    462
            /// @solidity memory-safe-assembly
    463
            assembly {
    464
                mstore(0x00, m0)
    465
                mstore(0x20, m1)
    466
                mstore(0x40, m2)
    467
            }
    468
        }
    469
    
                                                    
                                                
    470
        function log(uint256 p0, bytes32 p1) internal pure {
    471
            bytes32 m0;
    472
            bytes32 m1;
    473
            bytes32 m2;
    474
            bytes32 m3;
    475
            bytes32 m4;
    476
            /// @solidity memory-safe-assembly
    477
            assembly {
    478
                function writeString(pos, w) {
    479
                    let length := 0
    480
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    481
                    mstore(pos, length)
    482
                    let shift := sub(256, shl(3, length))
    483
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    484
                }
    485
                m0 := mload(0x00)
    486
                m1 := mload(0x20)
    487
                m2 := mload(0x40)
    488
                m3 := mload(0x60)
    489
                m4 := mload(0x80)
    490
                // Selector of `log(uint256,string)`.
    491
                mstore(0x00, 0x643fd0df)
    492
                mstore(0x20, p0)
    493
                mstore(0x40, 0x40)
    494
                writeString(0x60, p1)
    495
            }
    496
            _sendLogPayload(0x1c, 0x84);
    497
            /// @solidity memory-safe-assembly
    498
            assembly {
    499
                mstore(0x00, m0)
    500
                mstore(0x20, m1)
    501
                mstore(0x40, m2)
    502
                mstore(0x60, m3)
    503
                mstore(0x80, m4)
    504
            }
    505
        }
    506
    
                                                    
                                                
    507
        function log(bytes32 p0, address p1) internal pure {
    508
            bytes32 m0;
    509
            bytes32 m1;
    510
            bytes32 m2;
    511
            bytes32 m3;
    512
            bytes32 m4;
    513
            /// @solidity memory-safe-assembly
    514
            assembly {
    515
                function writeString(pos, w) {
    516
                    let length := 0
    517
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    518
                    mstore(pos, length)
    519
                    let shift := sub(256, shl(3, length))
    520
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    521
                }
    522
                m0 := mload(0x00)
    523
                m1 := mload(0x20)
    524
                m2 := mload(0x40)
    525
                m3 := mload(0x60)
    526
                m4 := mload(0x80)
    527
                // Selector of `log(string,address)`.
    528
                mstore(0x00, 0x319af333)
    529
                mstore(0x20, 0x40)
    530
                mstore(0x40, p1)
    531
                writeString(0x60, p0)
    532
            }
    533
            _sendLogPayload(0x1c, 0x84);
    534
            /// @solidity memory-safe-assembly
    535
            assembly {
    536
                mstore(0x00, m0)
    537
                mstore(0x20, m1)
    538
                mstore(0x40, m2)
    539
                mstore(0x60, m3)
    540
                mstore(0x80, m4)
    541
            }
    542
        }
    543
    
                                                    
                                                
    544
        function log(bytes32 p0, bool p1) internal pure {
    545
            bytes32 m0;
    546
            bytes32 m1;
    547
            bytes32 m2;
    548
            bytes32 m3;
    549
            bytes32 m4;
    550
            /// @solidity memory-safe-assembly
    551
            assembly {
    552
                function writeString(pos, w) {
    553
                    let length := 0
    554
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    555
                    mstore(pos, length)
    556
                    let shift := sub(256, shl(3, length))
    557
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    558
                }
    559
                m0 := mload(0x00)
    560
                m1 := mload(0x20)
    561
                m2 := mload(0x40)
    562
                m3 := mload(0x60)
    563
                m4 := mload(0x80)
    564
                // Selector of `log(string,bool)`.
    565
                mstore(0x00, 0xc3b55635)
    566
                mstore(0x20, 0x40)
    567
                mstore(0x40, p1)
    568
                writeString(0x60, p0)
    569
            }
    570
            _sendLogPayload(0x1c, 0x84);
    571
            /// @solidity memory-safe-assembly
    572
            assembly {
    573
                mstore(0x00, m0)
    574
                mstore(0x20, m1)
    575
                mstore(0x40, m2)
    576
                mstore(0x60, m3)
    577
                mstore(0x80, m4)
    578
            }
    579
        }
    580
    
                                                    
                                                
    581
        function log(bytes32 p0, uint256 p1) internal pure {
    582
            bytes32 m0;
    583
            bytes32 m1;
    584
            bytes32 m2;
    585
            bytes32 m3;
    586
            bytes32 m4;
    587
            /// @solidity memory-safe-assembly
    588
            assembly {
    589
                function writeString(pos, w) {
    590
                    let length := 0
    591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    592
                    mstore(pos, length)
    593
                    let shift := sub(256, shl(3, length))
    594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    595
                }
    596
                m0 := mload(0x00)
    597
                m1 := mload(0x20)
    598
                m2 := mload(0x40)
    599
                m3 := mload(0x60)
    600
                m4 := mload(0x80)
    601
                // Selector of `log(string,uint256)`.
    602
                mstore(0x00, 0xb60e72cc)
    603
                mstore(0x20, 0x40)
    604
                mstore(0x40, p1)
    605
                writeString(0x60, p0)
    606
            }
    607
            _sendLogPayload(0x1c, 0x84);
    608
            /// @solidity memory-safe-assembly
    609
            assembly {
    610
                mstore(0x00, m0)
    611
                mstore(0x20, m1)
    612
                mstore(0x40, m2)
    613
                mstore(0x60, m3)
    614
                mstore(0x80, m4)
    615
            }
    616
        }
    617
    
                                                    
                                                
    618
        function log(bytes32 p0, bytes32 p1) internal pure {
    619
            bytes32 m0;
    620
            bytes32 m1;
    621
            bytes32 m2;
    622
            bytes32 m3;
    623
            bytes32 m4;
    624
            bytes32 m5;
    625
            bytes32 m6;
    626
            /// @solidity memory-safe-assembly
    627
            assembly {
    628
                function writeString(pos, w) {
    629
                    let length := 0
    630
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    631
                    mstore(pos, length)
    632
                    let shift := sub(256, shl(3, length))
    633
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    634
                }
    635
                m0 := mload(0x00)
    636
                m1 := mload(0x20)
    637
                m2 := mload(0x40)
    638
                m3 := mload(0x60)
    639
                m4 := mload(0x80)
    640
                m5 := mload(0xa0)
    641
                m6 := mload(0xc0)
    642
                // Selector of `log(string,string)`.
    643
                mstore(0x00, 0x4b5c4277)
    644
                mstore(0x20, 0x40)
    645
                mstore(0x40, 0x80)
    646
                writeString(0x60, p0)
    647
                writeString(0xa0, p1)
    648
            }
    649
            _sendLogPayload(0x1c, 0xc4);
    650
            /// @solidity memory-safe-assembly
    651
            assembly {
    652
                mstore(0x00, m0)
    653
                mstore(0x20, m1)
    654
                mstore(0x40, m2)
    655
                mstore(0x60, m3)
    656
                mstore(0x80, m4)
    657
                mstore(0xa0, m5)
    658
                mstore(0xc0, m6)
    659
            }
    660
        }
    661
    
                                                    
                                                
    662
        function log(address p0, address p1, address p2) internal pure {
    663
            bytes32 m0;
    664
            bytes32 m1;
    665
            bytes32 m2;
    666
            bytes32 m3;
    667
            /// @solidity memory-safe-assembly
    668
            assembly {
    669
                m0 := mload(0x00)
    670
                m1 := mload(0x20)
    671
                m2 := mload(0x40)
    672
                m3 := mload(0x60)
    673
                // Selector of `log(address,address,address)`.
    674
                mstore(0x00, 0x018c84c2)
    675
                mstore(0x20, p0)
    676
                mstore(0x40, p1)
    677
                mstore(0x60, p2)
    678
            }
    679
            _sendLogPayload(0x1c, 0x64);
    680
            /// @solidity memory-safe-assembly
    681
            assembly {
    682
                mstore(0x00, m0)
    683
                mstore(0x20, m1)
    684
                mstore(0x40, m2)
    685
                mstore(0x60, m3)
    686
            }
    687
        }
    688
    
                                                    
                                                
    689
        function log(address p0, address p1, bool p2) internal pure {
    690
            bytes32 m0;
    691
            bytes32 m1;
    692
            bytes32 m2;
    693
            bytes32 m3;
    694
            /// @solidity memory-safe-assembly
    695
            assembly {
    696
                m0 := mload(0x00)
    697
                m1 := mload(0x20)
    698
                m2 := mload(0x40)
    699
                m3 := mload(0x60)
    700
                // Selector of `log(address,address,bool)`.
    701
                mstore(0x00, 0xf2a66286)
    702
                mstore(0x20, p0)
    703
                mstore(0x40, p1)
    704
                mstore(0x60, p2)
    705
            }
    706
            _sendLogPayload(0x1c, 0x64);
    707
            /// @solidity memory-safe-assembly
    708
            assembly {
    709
                mstore(0x00, m0)
    710
                mstore(0x20, m1)
    711
                mstore(0x40, m2)
    712
                mstore(0x60, m3)
    713
            }
    714
        }
    715
    
                                                    
                                                
    716
        function log(address p0, address p1, uint256 p2) internal pure {
    717
            bytes32 m0;
    718
            bytes32 m1;
    719
            bytes32 m2;
    720
            bytes32 m3;
    721
            /// @solidity memory-safe-assembly
    722
            assembly {
    723
                m0 := mload(0x00)
    724
                m1 := mload(0x20)
    725
                m2 := mload(0x40)
    726
                m3 := mload(0x60)
    727
                // Selector of `log(address,address,uint256)`.
    728
                mstore(0x00, 0x17fe6185)
    729
                mstore(0x20, p0)
    730
                mstore(0x40, p1)
    731
                mstore(0x60, p2)
    732
            }
    733
            _sendLogPayload(0x1c, 0x64);
    734
            /// @solidity memory-safe-assembly
    735
            assembly {
    736
                mstore(0x00, m0)
    737
                mstore(0x20, m1)
    738
                mstore(0x40, m2)
    739
                mstore(0x60, m3)
    740
            }
    741
        }
    742
    
                                                    
                                                
    743
        function log(address p0, address p1, bytes32 p2) internal pure {
    744
            bytes32 m0;
    745
            bytes32 m1;
    746
            bytes32 m2;
    747
            bytes32 m3;
    748
            bytes32 m4;
    749
            bytes32 m5;
    750
            /// @solidity memory-safe-assembly
    751
            assembly {
    752
                function writeString(pos, w) {
    753
                    let length := 0
    754
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    755
                    mstore(pos, length)
    756
                    let shift := sub(256, shl(3, length))
    757
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    758
                }
    759
                m0 := mload(0x00)
    760
                m1 := mload(0x20)
    761
                m2 := mload(0x40)
    762
                m3 := mload(0x60)
    763
                m4 := mload(0x80)
    764
                m5 := mload(0xa0)
    765
                // Selector of `log(address,address,string)`.
    766
                mstore(0x00, 0x007150be)
    767
                mstore(0x20, p0)
    768
                mstore(0x40, p1)
    769
                mstore(0x60, 0x60)
    770
                writeString(0x80, p2)
    771
            }
    772
            _sendLogPayload(0x1c, 0xa4);
    773
            /// @solidity memory-safe-assembly
    774
            assembly {
    775
                mstore(0x00, m0)
    776
                mstore(0x20, m1)
    777
                mstore(0x40, m2)
    778
                mstore(0x60, m3)
    779
                mstore(0x80, m4)
    780
                mstore(0xa0, m5)
    781
            }
    782
        }
    783
    
                                                    
                                                
    784
        function log(address p0, bool p1, address p2) internal pure {
    785
            bytes32 m0;
    786
            bytes32 m1;
    787
            bytes32 m2;
    788
            bytes32 m3;
    789
            /// @solidity memory-safe-assembly
    790
            assembly {
    791
                m0 := mload(0x00)
    792
                m1 := mload(0x20)
    793
                m2 := mload(0x40)
    794
                m3 := mload(0x60)
    795
                // Selector of `log(address,bool,address)`.
    796
                mstore(0x00, 0xf11699ed)
    797
                mstore(0x20, p0)
    798
                mstore(0x40, p1)
    799
                mstore(0x60, p2)
    800
            }
    801
            _sendLogPayload(0x1c, 0x64);
    802
            /// @solidity memory-safe-assembly
    803
            assembly {
    804
                mstore(0x00, m0)
    805
                mstore(0x20, m1)
    806
                mstore(0x40, m2)
    807
                mstore(0x60, m3)
    808
            }
    809
        }
    810
    
                                                    
                                                
    811
        function log(address p0, bool p1, bool p2) internal pure {
    812
            bytes32 m0;
    813
            bytes32 m1;
    814
            bytes32 m2;
    815
            bytes32 m3;
    816
            /// @solidity memory-safe-assembly
    817
            assembly {
    818
                m0 := mload(0x00)
    819
                m1 := mload(0x20)
    820
                m2 := mload(0x40)
    821
                m3 := mload(0x60)
    822
                // Selector of `log(address,bool,bool)`.
    823
                mstore(0x00, 0xeb830c92)
    824
                mstore(0x20, p0)
    825
                mstore(0x40, p1)
    826
                mstore(0x60, p2)
    827
            }
    828
            _sendLogPayload(0x1c, 0x64);
    829
            /// @solidity memory-safe-assembly
    830
            assembly {
    831
                mstore(0x00, m0)
    832
                mstore(0x20, m1)
    833
                mstore(0x40, m2)
    834
                mstore(0x60, m3)
    835
            }
    836
        }
    837
    
                                                    
                                                
    838
        function log(address p0, bool p1, uint256 p2) internal pure {
    839
            bytes32 m0;
    840
            bytes32 m1;
    841
            bytes32 m2;
    842
            bytes32 m3;
    843
            /// @solidity memory-safe-assembly
    844
            assembly {
    845
                m0 := mload(0x00)
    846
                m1 := mload(0x20)
    847
                m2 := mload(0x40)
    848
                m3 := mload(0x60)
    849
                // Selector of `log(address,bool,uint256)`.
    850
                mstore(0x00, 0x9c4f99fb)
    851
                mstore(0x20, p0)
    852
                mstore(0x40, p1)
    853
                mstore(0x60, p2)
    854
            }
    855
            _sendLogPayload(0x1c, 0x64);
    856
            /// @solidity memory-safe-assembly
    857
            assembly {
    858
                mstore(0x00, m0)
    859
                mstore(0x20, m1)
    860
                mstore(0x40, m2)
    861
                mstore(0x60, m3)
    862
            }
    863
        }
    864
    
                                                    
                                                
    865
        function log(address p0, bool p1, bytes32 p2) internal pure {
    866
            bytes32 m0;
    867
            bytes32 m1;
    868
            bytes32 m2;
    869
            bytes32 m3;
    870
            bytes32 m4;
    871
            bytes32 m5;
    872
            /// @solidity memory-safe-assembly
    873
            assembly {
    874
                function writeString(pos, w) {
    875
                    let length := 0
    876
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    877
                    mstore(pos, length)
    878
                    let shift := sub(256, shl(3, length))
    879
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    880
                }
    881
                m0 := mload(0x00)
    882
                m1 := mload(0x20)
    883
                m2 := mload(0x40)
    884
                m3 := mload(0x60)
    885
                m4 := mload(0x80)
    886
                m5 := mload(0xa0)
    887
                // Selector of `log(address,bool,string)`.
    888
                mstore(0x00, 0x212255cc)
    889
                mstore(0x20, p0)
    890
                mstore(0x40, p1)
    891
                mstore(0x60, 0x60)
    892
                writeString(0x80, p2)
    893
            }
    894
            _sendLogPayload(0x1c, 0xa4);
    895
            /// @solidity memory-safe-assembly
    896
            assembly {
    897
                mstore(0x00, m0)
    898
                mstore(0x20, m1)
    899
                mstore(0x40, m2)
    900
                mstore(0x60, m3)
    901
                mstore(0x80, m4)
    902
                mstore(0xa0, m5)
    903
            }
    904
        }
    905
    
                                                    
                                                
    906
        function log(address p0, uint256 p1, address p2) internal pure {
    907
            bytes32 m0;
    908
            bytes32 m1;
    909
            bytes32 m2;
    910
            bytes32 m3;
    911
            /// @solidity memory-safe-assembly
    912
            assembly {
    913
                m0 := mload(0x00)
    914
                m1 := mload(0x20)
    915
                m2 := mload(0x40)
    916
                m3 := mload(0x60)
    917
                // Selector of `log(address,uint256,address)`.
    918
                mstore(0x00, 0x7bc0d848)
    919
                mstore(0x20, p0)
    920
                mstore(0x40, p1)
    921
                mstore(0x60, p2)
    922
            }
    923
            _sendLogPayload(0x1c, 0x64);
    924
            /// @solidity memory-safe-assembly
    925
            assembly {
    926
                mstore(0x00, m0)
    927
                mstore(0x20, m1)
    928
                mstore(0x40, m2)
    929
                mstore(0x60, m3)
    930
            }
    931
        }
    932
    
                                                    
                                                
    933
        function log(address p0, uint256 p1, bool p2) internal pure {
    934
            bytes32 m0;
    935
            bytes32 m1;
    936
            bytes32 m2;
    937
            bytes32 m3;
    938
            /// @solidity memory-safe-assembly
    939
            assembly {
    940
                m0 := mload(0x00)
    941
                m1 := mload(0x20)
    942
                m2 := mload(0x40)
    943
                m3 := mload(0x60)
    944
                // Selector of `log(address,uint256,bool)`.
    945
                mstore(0x00, 0x678209a8)
    946
                mstore(0x20, p0)
    947
                mstore(0x40, p1)
    948
                mstore(0x60, p2)
    949
            }
    950
            _sendLogPayload(0x1c, 0x64);
    951
            /// @solidity memory-safe-assembly
    952
            assembly {
    953
                mstore(0x00, m0)
    954
                mstore(0x20, m1)
    955
                mstore(0x40, m2)
    956
                mstore(0x60, m3)
    957
            }
    958
        }
    959
    
                                                    
                                                
    960
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    961
            bytes32 m0;
    962
            bytes32 m1;
    963
            bytes32 m2;
    964
            bytes32 m3;
    965
            /// @solidity memory-safe-assembly
    966
            assembly {
    967
                m0 := mload(0x00)
    968
                m1 := mload(0x20)
    969
                m2 := mload(0x40)
    970
                m3 := mload(0x60)
    971
                // Selector of `log(address,uint256,uint256)`.
    972
                mstore(0x00, 0xb69bcaf6)
    973
                mstore(0x20, p0)
    974
                mstore(0x40, p1)
    975
                mstore(0x60, p2)
    976
            }
    977
            _sendLogPayload(0x1c, 0x64);
    978
            /// @solidity memory-safe-assembly
    979
            assembly {
    980
                mstore(0x00, m0)
    981
                mstore(0x20, m1)
    982
                mstore(0x40, m2)
    983
                mstore(0x60, m3)
    984
            }
    985
        }
    986
    
                                                    
                                                
    987
        function log(address p0, uint256 p1, bytes32 p2) internal pure {
    988
            bytes32 m0;
    989
            bytes32 m1;
    990
            bytes32 m2;
    991
            bytes32 m3;
    992
            bytes32 m4;
    993
            bytes32 m5;
    994
            /// @solidity memory-safe-assembly
    995
            assembly {
    996
                function writeString(pos, w) {
    997
                    let length := 0
    998
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    999
                    mstore(pos, length)
    1000
                    let shift := sub(256, shl(3, length))
    1001
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1002
                }
    1003
                m0 := mload(0x00)
    1004
                m1 := mload(0x20)
    1005
                m2 := mload(0x40)
    1006
                m3 := mload(0x60)
    1007
                m4 := mload(0x80)
    1008
                m5 := mload(0xa0)
    1009
                // Selector of `log(address,uint256,string)`.
    1010
                mstore(0x00, 0xa1f2e8aa)
    1011
                mstore(0x20, p0)
    1012
                mstore(0x40, p1)
    1013
                mstore(0x60, 0x60)
    1014
                writeString(0x80, p2)
    1015
            }
    1016
            _sendLogPayload(0x1c, 0xa4);
    1017
            /// @solidity memory-safe-assembly
    1018
            assembly {
    1019
                mstore(0x00, m0)
    1020
                mstore(0x20, m1)
    1021
                mstore(0x40, m2)
    1022
                mstore(0x60, m3)
    1023
                mstore(0x80, m4)
    1024
                mstore(0xa0, m5)
    1025
            }
    1026
        }
    1027
    
                                                    
                                                
    1028
        function log(address p0, bytes32 p1, address p2) internal pure {
    1029
            bytes32 m0;
    1030
            bytes32 m1;
    1031
            bytes32 m2;
    1032
            bytes32 m3;
    1033
            bytes32 m4;
    1034
            bytes32 m5;
    1035
            /// @solidity memory-safe-assembly
    1036
            assembly {
    1037
                function writeString(pos, w) {
    1038
                    let length := 0
    1039
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1040
                    mstore(pos, length)
    1041
                    let shift := sub(256, shl(3, length))
    1042
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1043
                }
    1044
                m0 := mload(0x00)
    1045
                m1 := mload(0x20)
    1046
                m2 := mload(0x40)
    1047
                m3 := mload(0x60)
    1048
                m4 := mload(0x80)
    1049
                m5 := mload(0xa0)
    1050
                // Selector of `log(address,string,address)`.
    1051
                mstore(0x00, 0xf08744e8)
    1052
                mstore(0x20, p0)
    1053
                mstore(0x40, 0x60)
    1054
                mstore(0x60, p2)
    1055
                writeString(0x80, p1)
    1056
            }
    1057
            _sendLogPayload(0x1c, 0xa4);
    1058
            /// @solidity memory-safe-assembly
    1059
            assembly {
    1060
                mstore(0x00, m0)
    1061
                mstore(0x20, m1)
    1062
                mstore(0x40, m2)
    1063
                mstore(0x60, m3)
    1064
                mstore(0x80, m4)
    1065
                mstore(0xa0, m5)
    1066
            }
    1067
        }
    1068
    
                                                    
                                                
    1069
        function log(address p0, bytes32 p1, bool p2) internal pure {
    1070
            bytes32 m0;
    1071
            bytes32 m1;
    1072
            bytes32 m2;
    1073
            bytes32 m3;
    1074
            bytes32 m4;
    1075
            bytes32 m5;
    1076
            /// @solidity memory-safe-assembly
    1077
            assembly {
    1078
                function writeString(pos, w) {
    1079
                    let length := 0
    1080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1081
                    mstore(pos, length)
    1082
                    let shift := sub(256, shl(3, length))
    1083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1084
                }
    1085
                m0 := mload(0x00)
    1086
                m1 := mload(0x20)
    1087
                m2 := mload(0x40)
    1088
                m3 := mload(0x60)
    1089
                m4 := mload(0x80)
    1090
                m5 := mload(0xa0)
    1091
                // Selector of `log(address,string,bool)`.
    1092
                mstore(0x00, 0xcf020fb1)
    1093
                mstore(0x20, p0)
    1094
                mstore(0x40, 0x60)
    1095
                mstore(0x60, p2)
    1096
                writeString(0x80, p1)
    1097
            }
    1098
            _sendLogPayload(0x1c, 0xa4);
    1099
            /// @solidity memory-safe-assembly
    1100
            assembly {
    1101
                mstore(0x00, m0)
    1102
                mstore(0x20, m1)
    1103
                mstore(0x40, m2)
    1104
                mstore(0x60, m3)
    1105
                mstore(0x80, m4)
    1106
                mstore(0xa0, m5)
    1107
            }
    1108
        }
    1109
    
                                                    
                                                
    1110
        function log(address p0, bytes32 p1, uint256 p2) internal pure {
    1111
            bytes32 m0;
    1112
            bytes32 m1;
    1113
            bytes32 m2;
    1114
            bytes32 m3;
    1115
            bytes32 m4;
    1116
            bytes32 m5;
    1117
            /// @solidity memory-safe-assembly
    1118
            assembly {
    1119
                function writeString(pos, w) {
    1120
                    let length := 0
    1121
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1122
                    mstore(pos, length)
    1123
                    let shift := sub(256, shl(3, length))
    1124
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1125
                }
    1126
                m0 := mload(0x00)
    1127
                m1 := mload(0x20)
    1128
                m2 := mload(0x40)
    1129
                m3 := mload(0x60)
    1130
                m4 := mload(0x80)
    1131
                m5 := mload(0xa0)
    1132
                // Selector of `log(address,string,uint256)`.
    1133
                mstore(0x00, 0x67dd6ff1)
    1134
                mstore(0x20, p0)
    1135
                mstore(0x40, 0x60)
    1136
                mstore(0x60, p2)
    1137
                writeString(0x80, p1)
    1138
            }
    1139
            _sendLogPayload(0x1c, 0xa4);
    1140
            /// @solidity memory-safe-assembly
    1141
            assembly {
    1142
                mstore(0x00, m0)
    1143
                mstore(0x20, m1)
    1144
                mstore(0x40, m2)
    1145
                mstore(0x60, m3)
    1146
                mstore(0x80, m4)
    1147
                mstore(0xa0, m5)
    1148
            }
    1149
        }
    1150
    
                                                    
                                                
    1151
        function log(address p0, bytes32 p1, bytes32 p2) internal pure {
    1152
            bytes32 m0;
    1153
            bytes32 m1;
    1154
            bytes32 m2;
    1155
            bytes32 m3;
    1156
            bytes32 m4;
    1157
            bytes32 m5;
    1158
            bytes32 m6;
    1159
            bytes32 m7;
    1160
            /// @solidity memory-safe-assembly
    1161
            assembly {
    1162
                function writeString(pos, w) {
    1163
                    let length := 0
    1164
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1165
                    mstore(pos, length)
    1166
                    let shift := sub(256, shl(3, length))
    1167
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1168
                }
    1169
                m0 := mload(0x00)
    1170
                m1 := mload(0x20)
    1171
                m2 := mload(0x40)
    1172
                m3 := mload(0x60)
    1173
                m4 := mload(0x80)
    1174
                m5 := mload(0xa0)
    1175
                m6 := mload(0xc0)
    1176
                m7 := mload(0xe0)
    1177
                // Selector of `log(address,string,string)`.
    1178
                mstore(0x00, 0xfb772265)
    1179
                mstore(0x20, p0)
    1180
                mstore(0x40, 0x60)
    1181
                mstore(0x60, 0xa0)
    1182
                writeString(0x80, p1)
    1183
                writeString(0xc0, p2)
    1184
            }
    1185
            _sendLogPayload(0x1c, 0xe4);
    1186
            /// @solidity memory-safe-assembly
    1187
            assembly {
    1188
                mstore(0x00, m0)
    1189
                mstore(0x20, m1)
    1190
                mstore(0x40, m2)
    1191
                mstore(0x60, m3)
    1192
                mstore(0x80, m4)
    1193
                mstore(0xa0, m5)
    1194
                mstore(0xc0, m6)
    1195
                mstore(0xe0, m7)
    1196
            }
    1197
        }
    1198
    
                                                    
                                                
    1199
        function log(bool p0, address p1, address p2) internal pure {
    1200
            bytes32 m0;
    1201
            bytes32 m1;
    1202
            bytes32 m2;
    1203
            bytes32 m3;
    1204
            /// @solidity memory-safe-assembly
    1205
            assembly {
    1206
                m0 := mload(0x00)
    1207
                m1 := mload(0x20)
    1208
                m2 := mload(0x40)
    1209
                m3 := mload(0x60)
    1210
                // Selector of `log(bool,address,address)`.
    1211
                mstore(0x00, 0xd2763667)
    1212
                mstore(0x20, p0)
    1213
                mstore(0x40, p1)
    1214
                mstore(0x60, p2)
    1215
            }
    1216
            _sendLogPayload(0x1c, 0x64);
    1217
            /// @solidity memory-safe-assembly
    1218
            assembly {
    1219
                mstore(0x00, m0)
    1220
                mstore(0x20, m1)
    1221
                mstore(0x40, m2)
    1222
                mstore(0x60, m3)
    1223
            }
    1224
        }
    1225
    
                                                    
                                                
    1226
        function log(bool p0, address p1, bool p2) internal pure {
    1227
            bytes32 m0;
    1228
            bytes32 m1;
    1229
            bytes32 m2;
    1230
            bytes32 m3;
    1231
            /// @solidity memory-safe-assembly
    1232
            assembly {
    1233
                m0 := mload(0x00)
    1234
                m1 := mload(0x20)
    1235
                m2 := mload(0x40)
    1236
                m3 := mload(0x60)
    1237
                // Selector of `log(bool,address,bool)`.
    1238
                mstore(0x00, 0x18c9c746)
    1239
                mstore(0x20, p0)
    1240
                mstore(0x40, p1)
    1241
                mstore(0x60, p2)
    1242
            }
    1243
            _sendLogPayload(0x1c, 0x64);
    1244
            /// @solidity memory-safe-assembly
    1245
            assembly {
    1246
                mstore(0x00, m0)
    1247
                mstore(0x20, m1)
    1248
                mstore(0x40, m2)
    1249
                mstore(0x60, m3)
    1250
            }
    1251
        }
    1252
    
                                                    
                                                
    1253
        function log(bool p0, address p1, uint256 p2) internal pure {
    1254
            bytes32 m0;
    1255
            bytes32 m1;
    1256
            bytes32 m2;
    1257
            bytes32 m3;
    1258
            /// @solidity memory-safe-assembly
    1259
            assembly {
    1260
                m0 := mload(0x00)
    1261
                m1 := mload(0x20)
    1262
                m2 := mload(0x40)
    1263
                m3 := mload(0x60)
    1264
                // Selector of `log(bool,address,uint256)`.
    1265
                mstore(0x00, 0x5f7b9afb)
    1266
                mstore(0x20, p0)
    1267
                mstore(0x40, p1)
    1268
                mstore(0x60, p2)
    1269
            }
    1270
            _sendLogPayload(0x1c, 0x64);
    1271
            /// @solidity memory-safe-assembly
    1272
            assembly {
    1273
                mstore(0x00, m0)
    1274
                mstore(0x20, m1)
    1275
                mstore(0x40, m2)
    1276
                mstore(0x60, m3)
    1277
            }
    1278
        }
    1279
    
                                                    
                                                
    1280
        function log(bool p0, address p1, bytes32 p2) internal pure {
    1281
            bytes32 m0;
    1282
            bytes32 m1;
    1283
            bytes32 m2;
    1284
            bytes32 m3;
    1285
            bytes32 m4;
    1286
            bytes32 m5;
    1287
            /// @solidity memory-safe-assembly
    1288
            assembly {
    1289
                function writeString(pos, w) {
    1290
                    let length := 0
    1291
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1292
                    mstore(pos, length)
    1293
                    let shift := sub(256, shl(3, length))
    1294
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1295
                }
    1296
                m0 := mload(0x00)
    1297
                m1 := mload(0x20)
    1298
                m2 := mload(0x40)
    1299
                m3 := mload(0x60)
    1300
                m4 := mload(0x80)
    1301
                m5 := mload(0xa0)
    1302
                // Selector of `log(bool,address,string)`.
    1303
                mstore(0x00, 0xde9a9270)
    1304
                mstore(0x20, p0)
    1305
                mstore(0x40, p1)
    1306
                mstore(0x60, 0x60)
    1307
                writeString(0x80, p2)
    1308
            }
    1309
            _sendLogPayload(0x1c, 0xa4);
    1310
            /// @solidity memory-safe-assembly
    1311
            assembly {
    1312
                mstore(0x00, m0)
    1313
                mstore(0x20, m1)
    1314
                mstore(0x40, m2)
    1315
                mstore(0x60, m3)
    1316
                mstore(0x80, m4)
    1317
                mstore(0xa0, m5)
    1318
            }
    1319
        }
    1320
    
                                                    
                                                
    1321
        function log(bool p0, bool p1, address p2) internal pure {
    1322
            bytes32 m0;
    1323
            bytes32 m1;
    1324
            bytes32 m2;
    1325
            bytes32 m3;
    1326
            /// @solidity memory-safe-assembly
    1327
            assembly {
    1328
                m0 := mload(0x00)
    1329
                m1 := mload(0x20)
    1330
                m2 := mload(0x40)
    1331
                m3 := mload(0x60)
    1332
                // Selector of `log(bool,bool,address)`.
    1333
                mstore(0x00, 0x1078f68d)
    1334
                mstore(0x20, p0)
    1335
                mstore(0x40, p1)
    1336
                mstore(0x60, p2)
    1337
            }
    1338
            _sendLogPayload(0x1c, 0x64);
    1339
            /// @solidity memory-safe-assembly
    1340
            assembly {
    1341
                mstore(0x00, m0)
    1342
                mstore(0x20, m1)
    1343
                mstore(0x40, m2)
    1344
                mstore(0x60, m3)
    1345
            }
    1346
        }
    1347
    
                                                    
                                                
    1348
        function log(bool p0, bool p1, bool p2) internal pure {
    1349
            bytes32 m0;
    1350
            bytes32 m1;
    1351
            bytes32 m2;
    1352
            bytes32 m3;
    1353
            /// @solidity memory-safe-assembly
    1354
            assembly {
    1355
                m0 := mload(0x00)
    1356
                m1 := mload(0x20)
    1357
                m2 := mload(0x40)
    1358
                m3 := mload(0x60)
    1359
                // Selector of `log(bool,bool,bool)`.
    1360
                mstore(0x00, 0x50709698)
    1361
                mstore(0x20, p0)
    1362
                mstore(0x40, p1)
    1363
                mstore(0x60, p2)
    1364
            }
    1365
            _sendLogPayload(0x1c, 0x64);
    1366
            /// @solidity memory-safe-assembly
    1367
            assembly {
    1368
                mstore(0x00, m0)
    1369
                mstore(0x20, m1)
    1370
                mstore(0x40, m2)
    1371
                mstore(0x60, m3)
    1372
            }
    1373
        }
    1374
    
                                                    
                                                
    1375
        function log(bool p0, bool p1, uint256 p2) internal pure {
    1376
            bytes32 m0;
    1377
            bytes32 m1;
    1378
            bytes32 m2;
    1379
            bytes32 m3;
    1380
            /// @solidity memory-safe-assembly
    1381
            assembly {
    1382
                m0 := mload(0x00)
    1383
                m1 := mload(0x20)
    1384
                m2 := mload(0x40)
    1385
                m3 := mload(0x60)
    1386
                // Selector of `log(bool,bool,uint256)`.
    1387
                mstore(0x00, 0x12f21602)
    1388
                mstore(0x20, p0)
    1389
                mstore(0x40, p1)
    1390
                mstore(0x60, p2)
    1391
            }
    1392
            _sendLogPayload(0x1c, 0x64);
    1393
            /// @solidity memory-safe-assembly
    1394
            assembly {
    1395
                mstore(0x00, m0)
    1396
                mstore(0x20, m1)
    1397
                mstore(0x40, m2)
    1398
                mstore(0x60, m3)
    1399
            }
    1400
        }
    1401
    
                                                    
                                                
    1402
        function log(bool p0, bool p1, bytes32 p2) internal pure {
    1403
            bytes32 m0;
    1404
            bytes32 m1;
    1405
            bytes32 m2;
    1406
            bytes32 m3;
    1407
            bytes32 m4;
    1408
            bytes32 m5;
    1409
            /// @solidity memory-safe-assembly
    1410
            assembly {
    1411
                function writeString(pos, w) {
    1412
                    let length := 0
    1413
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1414
                    mstore(pos, length)
    1415
                    let shift := sub(256, shl(3, length))
    1416
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1417
                }
    1418
                m0 := mload(0x00)
    1419
                m1 := mload(0x20)
    1420
                m2 := mload(0x40)
    1421
                m3 := mload(0x60)
    1422
                m4 := mload(0x80)
    1423
                m5 := mload(0xa0)
    1424
                // Selector of `log(bool,bool,string)`.
    1425
                mstore(0x00, 0x2555fa46)
    1426
                mstore(0x20, p0)
    1427
                mstore(0x40, p1)
    1428
                mstore(0x60, 0x60)
    1429
                writeString(0x80, p2)
    1430
            }
    1431
            _sendLogPayload(0x1c, 0xa4);
    1432
            /// @solidity memory-safe-assembly
    1433
            assembly {
    1434
                mstore(0x00, m0)
    1435
                mstore(0x20, m1)
    1436
                mstore(0x40, m2)
    1437
                mstore(0x60, m3)
    1438
                mstore(0x80, m4)
    1439
                mstore(0xa0, m5)
    1440
            }
    1441
        }
    1442
    
                                                    
                                                
    1443
        function log(bool p0, uint256 p1, address p2) internal pure {
    1444
            bytes32 m0;
    1445
            bytes32 m1;
    1446
            bytes32 m2;
    1447
            bytes32 m3;
    1448
            /// @solidity memory-safe-assembly
    1449
            assembly {
    1450
                m0 := mload(0x00)
    1451
                m1 := mload(0x20)
    1452
                m2 := mload(0x40)
    1453
                m3 := mload(0x60)
    1454
                // Selector of `log(bool,uint256,address)`.
    1455
                mstore(0x00, 0x088ef9d2)
    1456
                mstore(0x20, p0)
    1457
                mstore(0x40, p1)
    1458
                mstore(0x60, p2)
    1459
            }
    1460
            _sendLogPayload(0x1c, 0x64);
    1461
            /// @solidity memory-safe-assembly
    1462
            assembly {
    1463
                mstore(0x00, m0)
    1464
                mstore(0x20, m1)
    1465
                mstore(0x40, m2)
    1466
                mstore(0x60, m3)
    1467
            }
    1468
        }
    1469
    
                                                    
                                                
    1470
        function log(bool p0, uint256 p1, bool p2) internal pure {
    1471
            bytes32 m0;
    1472
            bytes32 m1;
    1473
            bytes32 m2;
    1474
            bytes32 m3;
    1475
            /// @solidity memory-safe-assembly
    1476
            assembly {
    1477
                m0 := mload(0x00)
    1478
                m1 := mload(0x20)
    1479
                m2 := mload(0x40)
    1480
                m3 := mload(0x60)
    1481
                // Selector of `log(bool,uint256,bool)`.
    1482
                mstore(0x00, 0xe8defba9)
    1483
                mstore(0x20, p0)
    1484
                mstore(0x40, p1)
    1485
                mstore(0x60, p2)
    1486
            }
    1487
            _sendLogPayload(0x1c, 0x64);
    1488
            /// @solidity memory-safe-assembly
    1489
            assembly {
    1490
                mstore(0x00, m0)
    1491
                mstore(0x20, m1)
    1492
                mstore(0x40, m2)
    1493
                mstore(0x60, m3)
    1494
            }
    1495
        }
    1496
    
                                                    
                                                
    1497
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    1498
            bytes32 m0;
    1499
            bytes32 m1;
    1500
            bytes32 m2;
    1501
            bytes32 m3;
    1502
            /// @solidity memory-safe-assembly
    1503
            assembly {
    1504
                m0 := mload(0x00)
    1505
                m1 := mload(0x20)
    1506
                m2 := mload(0x40)
    1507
                m3 := mload(0x60)
    1508
                // Selector of `log(bool,uint256,uint256)`.
    1509
                mstore(0x00, 0x37103367)
    1510
                mstore(0x20, p0)
    1511
                mstore(0x40, p1)
    1512
                mstore(0x60, p2)
    1513
            }
    1514
            _sendLogPayload(0x1c, 0x64);
    1515
            /// @solidity memory-safe-assembly
    1516
            assembly {
    1517
                mstore(0x00, m0)
    1518
                mstore(0x20, m1)
    1519
                mstore(0x40, m2)
    1520
                mstore(0x60, m3)
    1521
            }
    1522
        }
    1523
    
                                                    
                                                
    1524
        function log(bool p0, uint256 p1, bytes32 p2) internal pure {
    1525
            bytes32 m0;
    1526
            bytes32 m1;
    1527
            bytes32 m2;
    1528
            bytes32 m3;
    1529
            bytes32 m4;
    1530
            bytes32 m5;
    1531
            /// @solidity memory-safe-assembly
    1532
            assembly {
    1533
                function writeString(pos, w) {
    1534
                    let length := 0
    1535
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1536
                    mstore(pos, length)
    1537
                    let shift := sub(256, shl(3, length))
    1538
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1539
                }
    1540
                m0 := mload(0x00)
    1541
                m1 := mload(0x20)
    1542
                m2 := mload(0x40)
    1543
                m3 := mload(0x60)
    1544
                m4 := mload(0x80)
    1545
                m5 := mload(0xa0)
    1546
                // Selector of `log(bool,uint256,string)`.
    1547
                mstore(0x00, 0xc3fc3970)
    1548
                mstore(0x20, p0)
    1549
                mstore(0x40, p1)
    1550
                mstore(0x60, 0x60)
    1551
                writeString(0x80, p2)
    1552
            }
    1553
            _sendLogPayload(0x1c, 0xa4);
    1554
            /// @solidity memory-safe-assembly
    1555
            assembly {
    1556
                mstore(0x00, m0)
    1557
                mstore(0x20, m1)
    1558
                mstore(0x40, m2)
    1559
                mstore(0x60, m3)
    1560
                mstore(0x80, m4)
    1561
                mstore(0xa0, m5)
    1562
            }
    1563
        }
    1564
    
                                                    
                                                
    1565
        function log(bool p0, bytes32 p1, address p2) internal pure {
    1566
            bytes32 m0;
    1567
            bytes32 m1;
    1568
            bytes32 m2;
    1569
            bytes32 m3;
    1570
            bytes32 m4;
    1571
            bytes32 m5;
    1572
            /// @solidity memory-safe-assembly
    1573
            assembly {
    1574
                function writeString(pos, w) {
    1575
                    let length := 0
    1576
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1577
                    mstore(pos, length)
    1578
                    let shift := sub(256, shl(3, length))
    1579
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1580
                }
    1581
                m0 := mload(0x00)
    1582
                m1 := mload(0x20)
    1583
                m2 := mload(0x40)
    1584
                m3 := mload(0x60)
    1585
                m4 := mload(0x80)
    1586
                m5 := mload(0xa0)
    1587
                // Selector of `log(bool,string,address)`.
    1588
                mstore(0x00, 0x9591b953)
    1589
                mstore(0x20, p0)
    1590
                mstore(0x40, 0x60)
    1591
                mstore(0x60, p2)
    1592
                writeString(0x80, p1)
    1593
            }
    1594
            _sendLogPayload(0x1c, 0xa4);
    1595
            /// @solidity memory-safe-assembly
    1596
            assembly {
    1597
                mstore(0x00, m0)
    1598
                mstore(0x20, m1)
    1599
                mstore(0x40, m2)
    1600
                mstore(0x60, m3)
    1601
                mstore(0x80, m4)
    1602
                mstore(0xa0, m5)
    1603
            }
    1604
        }
    1605
    
                                                    
                                                
    1606
        function log(bool p0, bytes32 p1, bool p2) internal pure {
    1607
            bytes32 m0;
    1608
            bytes32 m1;
    1609
            bytes32 m2;
    1610
            bytes32 m3;
    1611
            bytes32 m4;
    1612
            bytes32 m5;
    1613
            /// @solidity memory-safe-assembly
    1614
            assembly {
    1615
                function writeString(pos, w) {
    1616
                    let length := 0
    1617
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1618
                    mstore(pos, length)
    1619
                    let shift := sub(256, shl(3, length))
    1620
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1621
                }
    1622
                m0 := mload(0x00)
    1623
                m1 := mload(0x20)
    1624
                m2 := mload(0x40)
    1625
                m3 := mload(0x60)
    1626
                m4 := mload(0x80)
    1627
                m5 := mload(0xa0)
    1628
                // Selector of `log(bool,string,bool)`.
    1629
                mstore(0x00, 0xdbb4c247)
    1630
                mstore(0x20, p0)
    1631
                mstore(0x40, 0x60)
    1632
                mstore(0x60, p2)
    1633
                writeString(0x80, p1)
    1634
            }
    1635
            _sendLogPayload(0x1c, 0xa4);
    1636
            /// @solidity memory-safe-assembly
    1637
            assembly {
    1638
                mstore(0x00, m0)
    1639
                mstore(0x20, m1)
    1640
                mstore(0x40, m2)
    1641
                mstore(0x60, m3)
    1642
                mstore(0x80, m4)
    1643
                mstore(0xa0, m5)
    1644
            }
    1645
        }
    1646
    
                                                    
                                                
    1647
        function log(bool p0, bytes32 p1, uint256 p2) internal pure {
    1648
            bytes32 m0;
    1649
            bytes32 m1;
    1650
            bytes32 m2;
    1651
            bytes32 m3;
    1652
            bytes32 m4;
    1653
            bytes32 m5;
    1654
            /// @solidity memory-safe-assembly
    1655
            assembly {
    1656
                function writeString(pos, w) {
    1657
                    let length := 0
    1658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1659
                    mstore(pos, length)
    1660
                    let shift := sub(256, shl(3, length))
    1661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1662
                }
    1663
                m0 := mload(0x00)
    1664
                m1 := mload(0x20)
    1665
                m2 := mload(0x40)
    1666
                m3 := mload(0x60)
    1667
                m4 := mload(0x80)
    1668
                m5 := mload(0xa0)
    1669
                // Selector of `log(bool,string,uint256)`.
    1670
                mstore(0x00, 0x1093ee11)
    1671
                mstore(0x20, p0)
    1672
                mstore(0x40, 0x60)
    1673
                mstore(0x60, p2)
    1674
                writeString(0x80, p1)
    1675
            }
    1676
            _sendLogPayload(0x1c, 0xa4);
    1677
            /// @solidity memory-safe-assembly
    1678
            assembly {
    1679
                mstore(0x00, m0)
    1680
                mstore(0x20, m1)
    1681
                mstore(0x40, m2)
    1682
                mstore(0x60, m3)
    1683
                mstore(0x80, m4)
    1684
                mstore(0xa0, m5)
    1685
            }
    1686
        }
    1687
    
                                                    
                                                
    1688
        function log(bool p0, bytes32 p1, bytes32 p2) internal pure {
    1689
            bytes32 m0;
    1690
            bytes32 m1;
    1691
            bytes32 m2;
    1692
            bytes32 m3;
    1693
            bytes32 m4;
    1694
            bytes32 m5;
    1695
            bytes32 m6;
    1696
            bytes32 m7;
    1697
            /// @solidity memory-safe-assembly
    1698
            assembly {
    1699
                function writeString(pos, w) {
    1700
                    let length := 0
    1701
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1702
                    mstore(pos, length)
    1703
                    let shift := sub(256, shl(3, length))
    1704
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1705
                }
    1706
                m0 := mload(0x00)
    1707
                m1 := mload(0x20)
    1708
                m2 := mload(0x40)
    1709
                m3 := mload(0x60)
    1710
                m4 := mload(0x80)
    1711
                m5 := mload(0xa0)
    1712
                m6 := mload(0xc0)
    1713
                m7 := mload(0xe0)
    1714
                // Selector of `log(bool,string,string)`.
    1715
                mstore(0x00, 0xb076847f)
    1716
                mstore(0x20, p0)
    1717
                mstore(0x40, 0x60)
    1718
                mstore(0x60, 0xa0)
    1719
                writeString(0x80, p1)
    1720
                writeString(0xc0, p2)
    1721
            }
    1722
            _sendLogPayload(0x1c, 0xe4);
    1723
            /// @solidity memory-safe-assembly
    1724
            assembly {
    1725
                mstore(0x00, m0)
    1726
                mstore(0x20, m1)
    1727
                mstore(0x40, m2)
    1728
                mstore(0x60, m3)
    1729
                mstore(0x80, m4)
    1730
                mstore(0xa0, m5)
    1731
                mstore(0xc0, m6)
    1732
                mstore(0xe0, m7)
    1733
            }
    1734
        }
    1735
    
                                                    
                                                
    1736
        function log(uint256 p0, address p1, address p2) internal pure {
    1737
            bytes32 m0;
    1738
            bytes32 m1;
    1739
            bytes32 m2;
    1740
            bytes32 m3;
    1741
            /// @solidity memory-safe-assembly
    1742
            assembly {
    1743
                m0 := mload(0x00)
    1744
                m1 := mload(0x20)
    1745
                m2 := mload(0x40)
    1746
                m3 := mload(0x60)
    1747
                // Selector of `log(uint256,address,address)`.
    1748
                mstore(0x00, 0xbcfd9be0)
    1749
                mstore(0x20, p0)
    1750
                mstore(0x40, p1)
    1751
                mstore(0x60, p2)
    1752
            }
    1753
            _sendLogPayload(0x1c, 0x64);
    1754
            /// @solidity memory-safe-assembly
    1755
            assembly {
    1756
                mstore(0x00, m0)
    1757
                mstore(0x20, m1)
    1758
                mstore(0x40, m2)
    1759
                mstore(0x60, m3)
    1760
            }
    1761
        }
    1762
    
                                                    
                                                
    1763
        function log(uint256 p0, address p1, bool p2) internal pure {
    1764
            bytes32 m0;
    1765
            bytes32 m1;
    1766
            bytes32 m2;
    1767
            bytes32 m3;
    1768
            /// @solidity memory-safe-assembly
    1769
            assembly {
    1770
                m0 := mload(0x00)
    1771
                m1 := mload(0x20)
    1772
                m2 := mload(0x40)
    1773
                m3 := mload(0x60)
    1774
                // Selector of `log(uint256,address,bool)`.
    1775
                mstore(0x00, 0x9b6ec042)
    1776
                mstore(0x20, p0)
    1777
                mstore(0x40, p1)
    1778
                mstore(0x60, p2)
    1779
            }
    1780
            _sendLogPayload(0x1c, 0x64);
    1781
            /// @solidity memory-safe-assembly
    1782
            assembly {
    1783
                mstore(0x00, m0)
    1784
                mstore(0x20, m1)
    1785
                mstore(0x40, m2)
    1786
                mstore(0x60, m3)
    1787
            }
    1788
        }
    1789
    
                                                    
                                                
    1790
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    1791
            bytes32 m0;
    1792
            bytes32 m1;
    1793
            bytes32 m2;
    1794
            bytes32 m3;
    1795
            /// @solidity memory-safe-assembly
    1796
            assembly {
    1797
                m0 := mload(0x00)
    1798
                m1 := mload(0x20)
    1799
                m2 := mload(0x40)
    1800
                m3 := mload(0x60)
    1801
                // Selector of `log(uint256,address,uint256)`.
    1802
                mstore(0x00, 0x5a9b5ed5)
    1803
                mstore(0x20, p0)
    1804
                mstore(0x40, p1)
    1805
                mstore(0x60, p2)
    1806
            }
    1807
            _sendLogPayload(0x1c, 0x64);
    1808
            /// @solidity memory-safe-assembly
    1809
            assembly {
    1810
                mstore(0x00, m0)
    1811
                mstore(0x20, m1)
    1812
                mstore(0x40, m2)
    1813
                mstore(0x60, m3)
    1814
            }
    1815
        }
    1816
    
                                                    
                                                
    1817
        function log(uint256 p0, address p1, bytes32 p2) internal pure {
    1818
            bytes32 m0;
    1819
            bytes32 m1;
    1820
            bytes32 m2;
    1821
            bytes32 m3;
    1822
            bytes32 m4;
    1823
            bytes32 m5;
    1824
            /// @solidity memory-safe-assembly
    1825
            assembly {
    1826
                function writeString(pos, w) {
    1827
                    let length := 0
    1828
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1829
                    mstore(pos, length)
    1830
                    let shift := sub(256, shl(3, length))
    1831
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1832
                }
    1833
                m0 := mload(0x00)
    1834
                m1 := mload(0x20)
    1835
                m2 := mload(0x40)
    1836
                m3 := mload(0x60)
    1837
                m4 := mload(0x80)
    1838
                m5 := mload(0xa0)
    1839
                // Selector of `log(uint256,address,string)`.
    1840
                mstore(0x00, 0x63cb41f9)
    1841
                mstore(0x20, p0)
    1842
                mstore(0x40, p1)
    1843
                mstore(0x60, 0x60)
    1844
                writeString(0x80, p2)
    1845
            }
    1846
            _sendLogPayload(0x1c, 0xa4);
    1847
            /// @solidity memory-safe-assembly
    1848
            assembly {
    1849
                mstore(0x00, m0)
    1850
                mstore(0x20, m1)
    1851
                mstore(0x40, m2)
    1852
                mstore(0x60, m3)
    1853
                mstore(0x80, m4)
    1854
                mstore(0xa0, m5)
    1855
            }
    1856
        }
    1857
    
                                                    
                                                
    1858
        function log(uint256 p0, bool p1, address p2) internal pure {
    1859
            bytes32 m0;
    1860
            bytes32 m1;
    1861
            bytes32 m2;
    1862
            bytes32 m3;
    1863
            /// @solidity memory-safe-assembly
    1864
            assembly {
    1865
                m0 := mload(0x00)
    1866
                m1 := mload(0x20)
    1867
                m2 := mload(0x40)
    1868
                m3 := mload(0x60)
    1869
                // Selector of `log(uint256,bool,address)`.
    1870
                mstore(0x00, 0x35085f7b)
    1871
                mstore(0x20, p0)
    1872
                mstore(0x40, p1)
    1873
                mstore(0x60, p2)
    1874
            }
    1875
            _sendLogPayload(0x1c, 0x64);
    1876
            /// @solidity memory-safe-assembly
    1877
            assembly {
    1878
                mstore(0x00, m0)
    1879
                mstore(0x20, m1)
    1880
                mstore(0x40, m2)
    1881
                mstore(0x60, m3)
    1882
            }
    1883
        }
    1884
    
                                                    
                                                
    1885
        function log(uint256 p0, bool p1, bool p2) internal pure {
    1886
            bytes32 m0;
    1887
            bytes32 m1;
    1888
            bytes32 m2;
    1889
            bytes32 m3;
    1890
            /// @solidity memory-safe-assembly
    1891
            assembly {
    1892
                m0 := mload(0x00)
    1893
                m1 := mload(0x20)
    1894
                m2 := mload(0x40)
    1895
                m3 := mload(0x60)
    1896
                // Selector of `log(uint256,bool,bool)`.
    1897
                mstore(0x00, 0x20718650)
    1898
                mstore(0x20, p0)
    1899
                mstore(0x40, p1)
    1900
                mstore(0x60, p2)
    1901
            }
    1902
            _sendLogPayload(0x1c, 0x64);
    1903
            /// @solidity memory-safe-assembly
    1904
            assembly {
    1905
                mstore(0x00, m0)
    1906
                mstore(0x20, m1)
    1907
                mstore(0x40, m2)
    1908
                mstore(0x60, m3)
    1909
            }
    1910
        }
    1911
    
                                                    
                                                
    1912
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    1913
            bytes32 m0;
    1914
            bytes32 m1;
    1915
            bytes32 m2;
    1916
            bytes32 m3;
    1917
            /// @solidity memory-safe-assembly
    1918
            assembly {
    1919
                m0 := mload(0x00)
    1920
                m1 := mload(0x20)
    1921
                m2 := mload(0x40)
    1922
                m3 := mload(0x60)
    1923
                // Selector of `log(uint256,bool,uint256)`.
    1924
                mstore(0x00, 0x20098014)
    1925
                mstore(0x20, p0)
    1926
                mstore(0x40, p1)
    1927
                mstore(0x60, p2)
    1928
            }
    1929
            _sendLogPayload(0x1c, 0x64);
    1930
            /// @solidity memory-safe-assembly
    1931
            assembly {
    1932
                mstore(0x00, m0)
    1933
                mstore(0x20, m1)
    1934
                mstore(0x40, m2)
    1935
                mstore(0x60, m3)
    1936
            }
    1937
        }
    1938
    
                                                    
                                                
    1939
        function log(uint256 p0, bool p1, bytes32 p2) internal pure {
    1940
            bytes32 m0;
    1941
            bytes32 m1;
    1942
            bytes32 m2;
    1943
            bytes32 m3;
    1944
            bytes32 m4;
    1945
            bytes32 m5;
    1946
            /// @solidity memory-safe-assembly
    1947
            assembly {
    1948
                function writeString(pos, w) {
    1949
                    let length := 0
    1950
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1951
                    mstore(pos, length)
    1952
                    let shift := sub(256, shl(3, length))
    1953
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1954
                }
    1955
                m0 := mload(0x00)
    1956
                m1 := mload(0x20)
    1957
                m2 := mload(0x40)
    1958
                m3 := mload(0x60)
    1959
                m4 := mload(0x80)
    1960
                m5 := mload(0xa0)
    1961
                // Selector of `log(uint256,bool,string)`.
    1962
                mstore(0x00, 0x85775021)
    1963
                mstore(0x20, p0)
    1964
                mstore(0x40, p1)
    1965
                mstore(0x60, 0x60)
    1966
                writeString(0x80, p2)
    1967
            }
    1968
            _sendLogPayload(0x1c, 0xa4);
    1969
            /// @solidity memory-safe-assembly
    1970
            assembly {
    1971
                mstore(0x00, m0)
    1972
                mstore(0x20, m1)
    1973
                mstore(0x40, m2)
    1974
                mstore(0x60, m3)
    1975
                mstore(0x80, m4)
    1976
                mstore(0xa0, m5)
    1977
            }
    1978
        }
    1979
    
                                                    
                                                
    1980
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    1981
            bytes32 m0;
    1982
            bytes32 m1;
    1983
            bytes32 m2;
    1984
            bytes32 m3;
    1985
            /// @solidity memory-safe-assembly
    1986
            assembly {
    1987
                m0 := mload(0x00)
    1988
                m1 := mload(0x20)
    1989
                m2 := mload(0x40)
    1990
                m3 := mload(0x60)
    1991
                // Selector of `log(uint256,uint256,address)`.
    1992
                mstore(0x00, 0x5c96b331)
    1993
                mstore(0x20, p0)
    1994
                mstore(0x40, p1)
    1995
                mstore(0x60, p2)
    1996
            }
    1997
            _sendLogPayload(0x1c, 0x64);
    1998
            /// @solidity memory-safe-assembly
    1999
            assembly {
    2000
                mstore(0x00, m0)
    2001
                mstore(0x20, m1)
    2002
                mstore(0x40, m2)
    2003
                mstore(0x60, m3)
    2004
            }
    2005
        }
    2006
    
                                                    
                                                
    2007
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    2008
            bytes32 m0;
    2009
            bytes32 m1;
    2010
            bytes32 m2;
    2011
            bytes32 m3;
    2012
            /// @solidity memory-safe-assembly
    2013
            assembly {
    2014
                m0 := mload(0x00)
    2015
                m1 := mload(0x20)
    2016
                m2 := mload(0x40)
    2017
                m3 := mload(0x60)
    2018
                // Selector of `log(uint256,uint256,bool)`.
    2019
                mstore(0x00, 0x4766da72)
    2020
                mstore(0x20, p0)
    2021
                mstore(0x40, p1)
    2022
                mstore(0x60, p2)
    2023
            }
    2024
            _sendLogPayload(0x1c, 0x64);
    2025
            /// @solidity memory-safe-assembly
    2026
            assembly {
    2027
                mstore(0x00, m0)
    2028
                mstore(0x20, m1)
    2029
                mstore(0x40, m2)
    2030
                mstore(0x60, m3)
    2031
            }
    2032
        }
    2033
    
                                                    
                                                
    2034
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    2035
            bytes32 m0;
    2036
            bytes32 m1;
    2037
            bytes32 m2;
    2038
            bytes32 m3;
    2039
            /// @solidity memory-safe-assembly
    2040
            assembly {
    2041
                m0 := mload(0x00)
    2042
                m1 := mload(0x20)
    2043
                m2 := mload(0x40)
    2044
                m3 := mload(0x60)
    2045
                // Selector of `log(uint256,uint256,uint256)`.
    2046
                mstore(0x00, 0xd1ed7a3c)
    2047
                mstore(0x20, p0)
    2048
                mstore(0x40, p1)
    2049
                mstore(0x60, p2)
    2050
            }
    2051
            _sendLogPayload(0x1c, 0x64);
    2052
            /// @solidity memory-safe-assembly
    2053
            assembly {
    2054
                mstore(0x00, m0)
    2055
                mstore(0x20, m1)
    2056
                mstore(0x40, m2)
    2057
                mstore(0x60, m3)
    2058
            }
    2059
        }
    2060
    
                                                    
                                                
    2061
        function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {
    2062
            bytes32 m0;
    2063
            bytes32 m1;
    2064
            bytes32 m2;
    2065
            bytes32 m3;
    2066
            bytes32 m4;
    2067
            bytes32 m5;
    2068
            /// @solidity memory-safe-assembly
    2069
            assembly {
    2070
                function writeString(pos, w) {
    2071
                    let length := 0
    2072
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2073
                    mstore(pos, length)
    2074
                    let shift := sub(256, shl(3, length))
    2075
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2076
                }
    2077
                m0 := mload(0x00)
    2078
                m1 := mload(0x20)
    2079
                m2 := mload(0x40)
    2080
                m3 := mload(0x60)
    2081
                m4 := mload(0x80)
    2082
                m5 := mload(0xa0)
    2083
                // Selector of `log(uint256,uint256,string)`.
    2084
                mstore(0x00, 0x71d04af2)
    2085
                mstore(0x20, p0)
    2086
                mstore(0x40, p1)
    2087
                mstore(0x60, 0x60)
    2088
                writeString(0x80, p2)
    2089
            }
    2090
            _sendLogPayload(0x1c, 0xa4);
    2091
            /// @solidity memory-safe-assembly
    2092
            assembly {
    2093
                mstore(0x00, m0)
    2094
                mstore(0x20, m1)
    2095
                mstore(0x40, m2)
    2096
                mstore(0x60, m3)
    2097
                mstore(0x80, m4)
    2098
                mstore(0xa0, m5)
    2099
            }
    2100
        }
    2101
    
                                                    
                                                
    2102
        function log(uint256 p0, bytes32 p1, address p2) internal pure {
    2103
            bytes32 m0;
    2104
            bytes32 m1;
    2105
            bytes32 m2;
    2106
            bytes32 m3;
    2107
            bytes32 m4;
    2108
            bytes32 m5;
    2109
            /// @solidity memory-safe-assembly
    2110
            assembly {
    2111
                function writeString(pos, w) {
    2112
                    let length := 0
    2113
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2114
                    mstore(pos, length)
    2115
                    let shift := sub(256, shl(3, length))
    2116
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2117
                }
    2118
                m0 := mload(0x00)
    2119
                m1 := mload(0x20)
    2120
                m2 := mload(0x40)
    2121
                m3 := mload(0x60)
    2122
                m4 := mload(0x80)
    2123
                m5 := mload(0xa0)
    2124
                // Selector of `log(uint256,string,address)`.
    2125
                mstore(0x00, 0x7afac959)
    2126
                mstore(0x20, p0)
    2127
                mstore(0x40, 0x60)
    2128
                mstore(0x60, p2)
    2129
                writeString(0x80, p1)
    2130
            }
    2131
            _sendLogPayload(0x1c, 0xa4);
    2132
            /// @solidity memory-safe-assembly
    2133
            assembly {
    2134
                mstore(0x00, m0)
    2135
                mstore(0x20, m1)
    2136
                mstore(0x40, m2)
    2137
                mstore(0x60, m3)
    2138
                mstore(0x80, m4)
    2139
                mstore(0xa0, m5)
    2140
            }
    2141
        }
    2142
    
                                                    
                                                
    2143
        function log(uint256 p0, bytes32 p1, bool p2) internal pure {
    2144
            bytes32 m0;
    2145
            bytes32 m1;
    2146
            bytes32 m2;
    2147
            bytes32 m3;
    2148
            bytes32 m4;
    2149
            bytes32 m5;
    2150
            /// @solidity memory-safe-assembly
    2151
            assembly {
    2152
                function writeString(pos, w) {
    2153
                    let length := 0
    2154
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2155
                    mstore(pos, length)
    2156
                    let shift := sub(256, shl(3, length))
    2157
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2158
                }
    2159
                m0 := mload(0x00)
    2160
                m1 := mload(0x20)
    2161
                m2 := mload(0x40)
    2162
                m3 := mload(0x60)
    2163
                m4 := mload(0x80)
    2164
                m5 := mload(0xa0)
    2165
                // Selector of `log(uint256,string,bool)`.
    2166
                mstore(0x00, 0x4ceda75a)
    2167
                mstore(0x20, p0)
    2168
                mstore(0x40, 0x60)
    2169
                mstore(0x60, p2)
    2170
                writeString(0x80, p1)
    2171
            }
    2172
            _sendLogPayload(0x1c, 0xa4);
    2173
            /// @solidity memory-safe-assembly
    2174
            assembly {
    2175
                mstore(0x00, m0)
    2176
                mstore(0x20, m1)
    2177
                mstore(0x40, m2)
    2178
                mstore(0x60, m3)
    2179
                mstore(0x80, m4)
    2180
                mstore(0xa0, m5)
    2181
            }
    2182
        }
    2183
    
                                                    
                                                
    2184
        function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {
    2185
            bytes32 m0;
    2186
            bytes32 m1;
    2187
            bytes32 m2;
    2188
            bytes32 m3;
    2189
            bytes32 m4;
    2190
            bytes32 m5;
    2191
            /// @solidity memory-safe-assembly
    2192
            assembly {
    2193
                function writeString(pos, w) {
    2194
                    let length := 0
    2195
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2196
                    mstore(pos, length)
    2197
                    let shift := sub(256, shl(3, length))
    2198
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2199
                }
    2200
                m0 := mload(0x00)
    2201
                m1 := mload(0x20)
    2202
                m2 := mload(0x40)
    2203
                m3 := mload(0x60)
    2204
                m4 := mload(0x80)
    2205
                m5 := mload(0xa0)
    2206
                // Selector of `log(uint256,string,uint256)`.
    2207
                mstore(0x00, 0x37aa7d4c)
    2208
                mstore(0x20, p0)
    2209
                mstore(0x40, 0x60)
    2210
                mstore(0x60, p2)
    2211
                writeString(0x80, p1)
    2212
            }
    2213
            _sendLogPayload(0x1c, 0xa4);
    2214
            /// @solidity memory-safe-assembly
    2215
            assembly {
    2216
                mstore(0x00, m0)
    2217
                mstore(0x20, m1)
    2218
                mstore(0x40, m2)
    2219
                mstore(0x60, m3)
    2220
                mstore(0x80, m4)
    2221
                mstore(0xa0, m5)
    2222
            }
    2223
        }
    2224
    
                                                    
                                                
    2225
        function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {
    2226
            bytes32 m0;
    2227
            bytes32 m1;
    2228
            bytes32 m2;
    2229
            bytes32 m3;
    2230
            bytes32 m4;
    2231
            bytes32 m5;
    2232
            bytes32 m6;
    2233
            bytes32 m7;
    2234
            /// @solidity memory-safe-assembly
    2235
            assembly {
    2236
                function writeString(pos, w) {
    2237
                    let length := 0
    2238
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2239
                    mstore(pos, length)
    2240
                    let shift := sub(256, shl(3, length))
    2241
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2242
                }
    2243
                m0 := mload(0x00)
    2244
                m1 := mload(0x20)
    2245
                m2 := mload(0x40)
    2246
                m3 := mload(0x60)
    2247
                m4 := mload(0x80)
    2248
                m5 := mload(0xa0)
    2249
                m6 := mload(0xc0)
    2250
                m7 := mload(0xe0)
    2251
                // Selector of `log(uint256,string,string)`.
    2252
                mstore(0x00, 0xb115611f)
    2253
                mstore(0x20, p0)
    2254
                mstore(0x40, 0x60)
    2255
                mstore(0x60, 0xa0)
    2256
                writeString(0x80, p1)
    2257
                writeString(0xc0, p2)
    2258
            }
    2259
            _sendLogPayload(0x1c, 0xe4);
    2260
            /// @solidity memory-safe-assembly
    2261
            assembly {
    2262
                mstore(0x00, m0)
    2263
                mstore(0x20, m1)
    2264
                mstore(0x40, m2)
    2265
                mstore(0x60, m3)
    2266
                mstore(0x80, m4)
    2267
                mstore(0xa0, m5)
    2268
                mstore(0xc0, m6)
    2269
                mstore(0xe0, m7)
    2270
            }
    2271
        }
    2272
    
                                                    
                                                
    2273
        function log(bytes32 p0, address p1, address p2) internal pure {
    2274
            bytes32 m0;
    2275
            bytes32 m1;
    2276
            bytes32 m2;
    2277
            bytes32 m3;
    2278
            bytes32 m4;
    2279
            bytes32 m5;
    2280
            /// @solidity memory-safe-assembly
    2281
            assembly {
    2282
                function writeString(pos, w) {
    2283
                    let length := 0
    2284
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2285
                    mstore(pos, length)
    2286
                    let shift := sub(256, shl(3, length))
    2287
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2288
                }
    2289
                m0 := mload(0x00)
    2290
                m1 := mload(0x20)
    2291
                m2 := mload(0x40)
    2292
                m3 := mload(0x60)
    2293
                m4 := mload(0x80)
    2294
                m5 := mload(0xa0)
    2295
                // Selector of `log(string,address,address)`.
    2296
                mstore(0x00, 0xfcec75e0)
    2297
                mstore(0x20, 0x60)
    2298
                mstore(0x40, p1)
    2299
                mstore(0x60, p2)
    2300
                writeString(0x80, p0)
    2301
            }
    2302
            _sendLogPayload(0x1c, 0xa4);
    2303
            /// @solidity memory-safe-assembly
    2304
            assembly {
    2305
                mstore(0x00, m0)
    2306
                mstore(0x20, m1)
    2307
                mstore(0x40, m2)
    2308
                mstore(0x60, m3)
    2309
                mstore(0x80, m4)
    2310
                mstore(0xa0, m5)
    2311
            }
    2312
        }
    2313
    
                                                    
                                                
    2314
        function log(bytes32 p0, address p1, bool p2) internal pure {
    2315
            bytes32 m0;
    2316
            bytes32 m1;
    2317
            bytes32 m2;
    2318
            bytes32 m3;
    2319
            bytes32 m4;
    2320
            bytes32 m5;
    2321
            /// @solidity memory-safe-assembly
    2322
            assembly {
    2323
                function writeString(pos, w) {
    2324
                    let length := 0
    2325
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2326
                    mstore(pos, length)
    2327
                    let shift := sub(256, shl(3, length))
    2328
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2329
                }
    2330
                m0 := mload(0x00)
    2331
                m1 := mload(0x20)
    2332
                m2 := mload(0x40)
    2333
                m3 := mload(0x60)
    2334
                m4 := mload(0x80)
    2335
                m5 := mload(0xa0)
    2336
                // Selector of `log(string,address,bool)`.
    2337
                mstore(0x00, 0xc91d5ed4)
    2338
                mstore(0x20, 0x60)
    2339
                mstore(0x40, p1)
    2340
                mstore(0x60, p2)
    2341
                writeString(0x80, p0)
    2342
            }
    2343
            _sendLogPayload(0x1c, 0xa4);
    2344
            /// @solidity memory-safe-assembly
    2345
            assembly {
    2346
                mstore(0x00, m0)
    2347
                mstore(0x20, m1)
    2348
                mstore(0x40, m2)
    2349
                mstore(0x60, m3)
    2350
                mstore(0x80, m4)
    2351
                mstore(0xa0, m5)
    2352
            }
    2353
        }
    2354
    
                                                    
                                                
    2355
        function log(bytes32 p0, address p1, uint256 p2) internal pure {
    2356
            bytes32 m0;
    2357
            bytes32 m1;
    2358
            bytes32 m2;
    2359
            bytes32 m3;
    2360
            bytes32 m4;
    2361
            bytes32 m5;
    2362
            /// @solidity memory-safe-assembly
    2363
            assembly {
    2364
                function writeString(pos, w) {
    2365
                    let length := 0
    2366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2367
                    mstore(pos, length)
    2368
                    let shift := sub(256, shl(3, length))
    2369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2370
                }
    2371
                m0 := mload(0x00)
    2372
                m1 := mload(0x20)
    2373
                m2 := mload(0x40)
    2374
                m3 := mload(0x60)
    2375
                m4 := mload(0x80)
    2376
                m5 := mload(0xa0)
    2377
                // Selector of `log(string,address,uint256)`.
    2378
                mstore(0x00, 0x0d26b925)
    2379
                mstore(0x20, 0x60)
    2380
                mstore(0x40, p1)
    2381
                mstore(0x60, p2)
    2382
                writeString(0x80, p0)
    2383
            }
    2384
            _sendLogPayload(0x1c, 0xa4);
    2385
            /// @solidity memory-safe-assembly
    2386
            assembly {
    2387
                mstore(0x00, m0)
    2388
                mstore(0x20, m1)
    2389
                mstore(0x40, m2)
    2390
                mstore(0x60, m3)
    2391
                mstore(0x80, m4)
    2392
                mstore(0xa0, m5)
    2393
            }
    2394
        }
    2395
    
                                                    
                                                
    2396
        function log(bytes32 p0, address p1, bytes32 p2) internal pure {
    2397
            bytes32 m0;
    2398
            bytes32 m1;
    2399
            bytes32 m2;
    2400
            bytes32 m3;
    2401
            bytes32 m4;
    2402
            bytes32 m5;
    2403
            bytes32 m6;
    2404
            bytes32 m7;
    2405
            /// @solidity memory-safe-assembly
    2406
            assembly {
    2407
                function writeString(pos, w) {
    2408
                    let length := 0
    2409
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2410
                    mstore(pos, length)
    2411
                    let shift := sub(256, shl(3, length))
    2412
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2413
                }
    2414
                m0 := mload(0x00)
    2415
                m1 := mload(0x20)
    2416
                m2 := mload(0x40)
    2417
                m3 := mload(0x60)
    2418
                m4 := mload(0x80)
    2419
                m5 := mload(0xa0)
    2420
                m6 := mload(0xc0)
    2421
                m7 := mload(0xe0)
    2422
                // Selector of `log(string,address,string)`.
    2423
                mstore(0x00, 0xe0e9ad4f)
    2424
                mstore(0x20, 0x60)
    2425
                mstore(0x40, p1)
    2426
                mstore(0x60, 0xa0)
    2427
                writeString(0x80, p0)
    2428
                writeString(0xc0, p2)
    2429
            }
    2430
            _sendLogPayload(0x1c, 0xe4);
    2431
            /// @solidity memory-safe-assembly
    2432
            assembly {
    2433
                mstore(0x00, m0)
    2434
                mstore(0x20, m1)
    2435
                mstore(0x40, m2)
    2436
                mstore(0x60, m3)
    2437
                mstore(0x80, m4)
    2438
                mstore(0xa0, m5)
    2439
                mstore(0xc0, m6)
    2440
                mstore(0xe0, m7)
    2441
            }
    2442
        }
    2443
    
                                                    
                                                
    2444
        function log(bytes32 p0, bool p1, address p2) internal pure {
    2445
            bytes32 m0;
    2446
            bytes32 m1;
    2447
            bytes32 m2;
    2448
            bytes32 m3;
    2449
            bytes32 m4;
    2450
            bytes32 m5;
    2451
            /// @solidity memory-safe-assembly
    2452
            assembly {
    2453
                function writeString(pos, w) {
    2454
                    let length := 0
    2455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2456
                    mstore(pos, length)
    2457
                    let shift := sub(256, shl(3, length))
    2458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2459
                }
    2460
                m0 := mload(0x00)
    2461
                m1 := mload(0x20)
    2462
                m2 := mload(0x40)
    2463
                m3 := mload(0x60)
    2464
                m4 := mload(0x80)
    2465
                m5 := mload(0xa0)
    2466
                // Selector of `log(string,bool,address)`.
    2467
                mstore(0x00, 0x932bbb38)
    2468
                mstore(0x20, 0x60)
    2469
                mstore(0x40, p1)
    2470
                mstore(0x60, p2)
    2471
                writeString(0x80, p0)
    2472
            }
    2473
            _sendLogPayload(0x1c, 0xa4);
    2474
            /// @solidity memory-safe-assembly
    2475
            assembly {
    2476
                mstore(0x00, m0)
    2477
                mstore(0x20, m1)
    2478
                mstore(0x40, m2)
    2479
                mstore(0x60, m3)
    2480
                mstore(0x80, m4)
    2481
                mstore(0xa0, m5)
    2482
            }
    2483
        }
    2484
    
                                                    
                                                
    2485
        function log(bytes32 p0, bool p1, bool p2) internal pure {
    2486
            bytes32 m0;
    2487
            bytes32 m1;
    2488
            bytes32 m2;
    2489
            bytes32 m3;
    2490
            bytes32 m4;
    2491
            bytes32 m5;
    2492
            /// @solidity memory-safe-assembly
    2493
            assembly {
    2494
                function writeString(pos, w) {
    2495
                    let length := 0
    2496
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2497
                    mstore(pos, length)
    2498
                    let shift := sub(256, shl(3, length))
    2499
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2500
                }
    2501
                m0 := mload(0x00)
    2502
                m1 := mload(0x20)
    2503
                m2 := mload(0x40)
    2504
                m3 := mload(0x60)
    2505
                m4 := mload(0x80)
    2506
                m5 := mload(0xa0)
    2507
                // Selector of `log(string,bool,bool)`.
    2508
                mstore(0x00, 0x850b7ad6)
    2509
                mstore(0x20, 0x60)
    2510
                mstore(0x40, p1)
    2511
                mstore(0x60, p2)
    2512
                writeString(0x80, p0)
    2513
            }
    2514
            _sendLogPayload(0x1c, 0xa4);
    2515
            /// @solidity memory-safe-assembly
    2516
            assembly {
    2517
                mstore(0x00, m0)
    2518
                mstore(0x20, m1)
    2519
                mstore(0x40, m2)
    2520
                mstore(0x60, m3)
    2521
                mstore(0x80, m4)
    2522
                mstore(0xa0, m5)
    2523
            }
    2524
        }
    2525
    
                                                    
                                                
    2526
        function log(bytes32 p0, bool p1, uint256 p2) internal pure {
    2527
            bytes32 m0;
    2528
            bytes32 m1;
    2529
            bytes32 m2;
    2530
            bytes32 m3;
    2531
            bytes32 m4;
    2532
            bytes32 m5;
    2533
            /// @solidity memory-safe-assembly
    2534
            assembly {
    2535
                function writeString(pos, w) {
    2536
                    let length := 0
    2537
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2538
                    mstore(pos, length)
    2539
                    let shift := sub(256, shl(3, length))
    2540
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2541
                }
    2542
                m0 := mload(0x00)
    2543
                m1 := mload(0x20)
    2544
                m2 := mload(0x40)
    2545
                m3 := mload(0x60)
    2546
                m4 := mload(0x80)
    2547
                m5 := mload(0xa0)
    2548
                // Selector of `log(string,bool,uint256)`.
    2549
                mstore(0x00, 0xc95958d6)
    2550
                mstore(0x20, 0x60)
    2551
                mstore(0x40, p1)
    2552
                mstore(0x60, p2)
    2553
                writeString(0x80, p0)
    2554
            }
    2555
            _sendLogPayload(0x1c, 0xa4);
    2556
            /// @solidity memory-safe-assembly
    2557
            assembly {
    2558
                mstore(0x00, m0)
    2559
                mstore(0x20, m1)
    2560
                mstore(0x40, m2)
    2561
                mstore(0x60, m3)
    2562
                mstore(0x80, m4)
    2563
                mstore(0xa0, m5)
    2564
            }
    2565
        }
    2566
    
                                                    
                                                
    2567
        function log(bytes32 p0, bool p1, bytes32 p2) internal pure {
    2568
            bytes32 m0;
    2569
            bytes32 m1;
    2570
            bytes32 m2;
    2571
            bytes32 m3;
    2572
            bytes32 m4;
    2573
            bytes32 m5;
    2574
            bytes32 m6;
    2575
            bytes32 m7;
    2576
            /// @solidity memory-safe-assembly
    2577
            assembly {
    2578
                function writeString(pos, w) {
    2579
                    let length := 0
    2580
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2581
                    mstore(pos, length)
    2582
                    let shift := sub(256, shl(3, length))
    2583
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2584
                }
    2585
                m0 := mload(0x00)
    2586
                m1 := mload(0x20)
    2587
                m2 := mload(0x40)
    2588
                m3 := mload(0x60)
    2589
                m4 := mload(0x80)
    2590
                m5 := mload(0xa0)
    2591
                m6 := mload(0xc0)
    2592
                m7 := mload(0xe0)
    2593
                // Selector of `log(string,bool,string)`.
    2594
                mstore(0x00, 0xe298f47d)
    2595
                mstore(0x20, 0x60)
    2596
                mstore(0x40, p1)
    2597
                mstore(0x60, 0xa0)
    2598
                writeString(0x80, p0)
    2599
                writeString(0xc0, p2)
    2600
            }
    2601
            _sendLogPayload(0x1c, 0xe4);
    2602
            /// @solidity memory-safe-assembly
    2603
            assembly {
    2604
                mstore(0x00, m0)
    2605
                mstore(0x20, m1)
    2606
                mstore(0x40, m2)
    2607
                mstore(0x60, m3)
    2608
                mstore(0x80, m4)
    2609
                mstore(0xa0, m5)
    2610
                mstore(0xc0, m6)
    2611
                mstore(0xe0, m7)
    2612
            }
    2613
        }
    2614
    
                                                    
                                                
    2615
        function log(bytes32 p0, uint256 p1, address p2) internal pure {
    2616
            bytes32 m0;
    2617
            bytes32 m1;
    2618
            bytes32 m2;
    2619
            bytes32 m3;
    2620
            bytes32 m4;
    2621
            bytes32 m5;
    2622
            /// @solidity memory-safe-assembly
    2623
            assembly {
    2624
                function writeString(pos, w) {
    2625
                    let length := 0
    2626
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2627
                    mstore(pos, length)
    2628
                    let shift := sub(256, shl(3, length))
    2629
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2630
                }
    2631
                m0 := mload(0x00)
    2632
                m1 := mload(0x20)
    2633
                m2 := mload(0x40)
    2634
                m3 := mload(0x60)
    2635
                m4 := mload(0x80)
    2636
                m5 := mload(0xa0)
    2637
                // Selector of `log(string,uint256,address)`.
    2638
                mstore(0x00, 0x1c7ec448)
    2639
                mstore(0x20, 0x60)
    2640
                mstore(0x40, p1)
    2641
                mstore(0x60, p2)
    2642
                writeString(0x80, p0)
    2643
            }
    2644
            _sendLogPayload(0x1c, 0xa4);
    2645
            /// @solidity memory-safe-assembly
    2646
            assembly {
    2647
                mstore(0x00, m0)
    2648
                mstore(0x20, m1)
    2649
                mstore(0x40, m2)
    2650
                mstore(0x60, m3)
    2651
                mstore(0x80, m4)
    2652
                mstore(0xa0, m5)
    2653
            }
    2654
        }
    2655
    
                                                    
                                                
    2656
        function log(bytes32 p0, uint256 p1, bool p2) internal pure {
    2657
            bytes32 m0;
    2658
            bytes32 m1;
    2659
            bytes32 m2;
    2660
            bytes32 m3;
    2661
            bytes32 m4;
    2662
            bytes32 m5;
    2663
            /// @solidity memory-safe-assembly
    2664
            assembly {
    2665
                function writeString(pos, w) {
    2666
                    let length := 0
    2667
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2668
                    mstore(pos, length)
    2669
                    let shift := sub(256, shl(3, length))
    2670
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2671
                }
    2672
                m0 := mload(0x00)
    2673
                m1 := mload(0x20)
    2674
                m2 := mload(0x40)
    2675
                m3 := mload(0x60)
    2676
                m4 := mload(0x80)
    2677
                m5 := mload(0xa0)
    2678
                // Selector of `log(string,uint256,bool)`.
    2679
                mstore(0x00, 0xca7733b1)
    2680
                mstore(0x20, 0x60)
    2681
                mstore(0x40, p1)
    2682
                mstore(0x60, p2)
    2683
                writeString(0x80, p0)
    2684
            }
    2685
            _sendLogPayload(0x1c, 0xa4);
    2686
            /// @solidity memory-safe-assembly
    2687
            assembly {
    2688
                mstore(0x00, m0)
    2689
                mstore(0x20, m1)
    2690
                mstore(0x40, m2)
    2691
                mstore(0x60, m3)
    2692
                mstore(0x80, m4)
    2693
                mstore(0xa0, m5)
    2694
            }
    2695
        }
    2696
    
                                                    
                                                
    2697
        function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {
    2698
            bytes32 m0;
    2699
            bytes32 m1;
    2700
            bytes32 m2;
    2701
            bytes32 m3;
    2702
            bytes32 m4;
    2703
            bytes32 m5;
    2704
            /// @solidity memory-safe-assembly
    2705
            assembly {
    2706
                function writeString(pos, w) {
    2707
                    let length := 0
    2708
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2709
                    mstore(pos, length)
    2710
                    let shift := sub(256, shl(3, length))
    2711
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2712
                }
    2713
                m0 := mload(0x00)
    2714
                m1 := mload(0x20)
    2715
                m2 := mload(0x40)
    2716
                m3 := mload(0x60)
    2717
                m4 := mload(0x80)
    2718
                m5 := mload(0xa0)
    2719
                // Selector of `log(string,uint256,uint256)`.
    2720
                mstore(0x00, 0xca47c4eb)
    2721
                mstore(0x20, 0x60)
    2722
                mstore(0x40, p1)
    2723
                mstore(0x60, p2)
    2724
                writeString(0x80, p0)
    2725
            }
    2726
            _sendLogPayload(0x1c, 0xa4);
    2727
            /// @solidity memory-safe-assembly
    2728
            assembly {
    2729
                mstore(0x00, m0)
    2730
                mstore(0x20, m1)
    2731
                mstore(0x40, m2)
    2732
                mstore(0x60, m3)
    2733
                mstore(0x80, m4)
    2734
                mstore(0xa0, m5)
    2735
            }
    2736
        }
    2737
    
                                                    
                                                
    2738
        function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {
    2739
            bytes32 m0;
    2740
            bytes32 m1;
    2741
            bytes32 m2;
    2742
            bytes32 m3;
    2743
            bytes32 m4;
    2744
            bytes32 m5;
    2745
            bytes32 m6;
    2746
            bytes32 m7;
    2747
            /// @solidity memory-safe-assembly
    2748
            assembly {
    2749
                function writeString(pos, w) {
    2750
                    let length := 0
    2751
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2752
                    mstore(pos, length)
    2753
                    let shift := sub(256, shl(3, length))
    2754
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2755
                }
    2756
                m0 := mload(0x00)
    2757
                m1 := mload(0x20)
    2758
                m2 := mload(0x40)
    2759
                m3 := mload(0x60)
    2760
                m4 := mload(0x80)
    2761
                m5 := mload(0xa0)
    2762
                m6 := mload(0xc0)
    2763
                m7 := mload(0xe0)
    2764
                // Selector of `log(string,uint256,string)`.
    2765
                mstore(0x00, 0x5970e089)
    2766
                mstore(0x20, 0x60)
    2767
                mstore(0x40, p1)
    2768
                mstore(0x60, 0xa0)
    2769
                writeString(0x80, p0)
    2770
                writeString(0xc0, p2)
    2771
            }
    2772
            _sendLogPayload(0x1c, 0xe4);
    2773
            /// @solidity memory-safe-assembly
    2774
            assembly {
    2775
                mstore(0x00, m0)
    2776
                mstore(0x20, m1)
    2777
                mstore(0x40, m2)
    2778
                mstore(0x60, m3)
    2779
                mstore(0x80, m4)
    2780
                mstore(0xa0, m5)
    2781
                mstore(0xc0, m6)
    2782
                mstore(0xe0, m7)
    2783
            }
    2784
        }
    2785
    
                                                    
                                                
    2786
        function log(bytes32 p0, bytes32 p1, address p2) internal pure {
    2787
            bytes32 m0;
    2788
            bytes32 m1;
    2789
            bytes32 m2;
    2790
            bytes32 m3;
    2791
            bytes32 m4;
    2792
            bytes32 m5;
    2793
            bytes32 m6;
    2794
            bytes32 m7;
    2795
            /// @solidity memory-safe-assembly
    2796
            assembly {
    2797
                function writeString(pos, w) {
    2798
                    let length := 0
    2799
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2800
                    mstore(pos, length)
    2801
                    let shift := sub(256, shl(3, length))
    2802
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2803
                }
    2804
                m0 := mload(0x00)
    2805
                m1 := mload(0x20)
    2806
                m2 := mload(0x40)
    2807
                m3 := mload(0x60)
    2808
                m4 := mload(0x80)
    2809
                m5 := mload(0xa0)
    2810
                m6 := mload(0xc0)
    2811
                m7 := mload(0xe0)
    2812
                // Selector of `log(string,string,address)`.
    2813
                mstore(0x00, 0x95ed0195)
    2814
                mstore(0x20, 0x60)
    2815
                mstore(0x40, 0xa0)
    2816
                mstore(0x60, p2)
    2817
                writeString(0x80, p0)
    2818
                writeString(0xc0, p1)
    2819
            }
    2820
            _sendLogPayload(0x1c, 0xe4);
    2821
            /// @solidity memory-safe-assembly
    2822
            assembly {
    2823
                mstore(0x00, m0)
    2824
                mstore(0x20, m1)
    2825
                mstore(0x40, m2)
    2826
                mstore(0x60, m3)
    2827
                mstore(0x80, m4)
    2828
                mstore(0xa0, m5)
    2829
                mstore(0xc0, m6)
    2830
                mstore(0xe0, m7)
    2831
            }
    2832
        }
    2833
    
                                                    
                                                
    2834
        function log(bytes32 p0, bytes32 p1, bool p2) internal pure {
    2835
            bytes32 m0;
    2836
            bytes32 m1;
    2837
            bytes32 m2;
    2838
            bytes32 m3;
    2839
            bytes32 m4;
    2840
            bytes32 m5;
    2841
            bytes32 m6;
    2842
            bytes32 m7;
    2843
            /// @solidity memory-safe-assembly
    2844
            assembly {
    2845
                function writeString(pos, w) {
    2846
                    let length := 0
    2847
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2848
                    mstore(pos, length)
    2849
                    let shift := sub(256, shl(3, length))
    2850
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2851
                }
    2852
                m0 := mload(0x00)
    2853
                m1 := mload(0x20)
    2854
                m2 := mload(0x40)
    2855
                m3 := mload(0x60)
    2856
                m4 := mload(0x80)
    2857
                m5 := mload(0xa0)
    2858
                m6 := mload(0xc0)
    2859
                m7 := mload(0xe0)
    2860
                // Selector of `log(string,string,bool)`.
    2861
                mstore(0x00, 0xb0e0f9b5)
    2862
                mstore(0x20, 0x60)
    2863
                mstore(0x40, 0xa0)
    2864
                mstore(0x60, p2)
    2865
                writeString(0x80, p0)
    2866
                writeString(0xc0, p1)
    2867
            }
    2868
            _sendLogPayload(0x1c, 0xe4);
    2869
            /// @solidity memory-safe-assembly
    2870
            assembly {
    2871
                mstore(0x00, m0)
    2872
                mstore(0x20, m1)
    2873
                mstore(0x40, m2)
    2874
                mstore(0x60, m3)
    2875
                mstore(0x80, m4)
    2876
                mstore(0xa0, m5)
    2877
                mstore(0xc0, m6)
    2878
                mstore(0xe0, m7)
    2879
            }
    2880
        }
    2881
    
                                                    
                                                
    2882
        function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {
    2883
            bytes32 m0;
    2884
            bytes32 m1;
    2885
            bytes32 m2;
    2886
            bytes32 m3;
    2887
            bytes32 m4;
    2888
            bytes32 m5;
    2889
            bytes32 m6;
    2890
            bytes32 m7;
    2891
            /// @solidity memory-safe-assembly
    2892
            assembly {
    2893
                function writeString(pos, w) {
    2894
                    let length := 0
    2895
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2896
                    mstore(pos, length)
    2897
                    let shift := sub(256, shl(3, length))
    2898
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2899
                }
    2900
                m0 := mload(0x00)
    2901
                m1 := mload(0x20)
    2902
                m2 := mload(0x40)
    2903
                m3 := mload(0x60)
    2904
                m4 := mload(0x80)
    2905
                m5 := mload(0xa0)
    2906
                m6 := mload(0xc0)
    2907
                m7 := mload(0xe0)
    2908
                // Selector of `log(string,string,uint256)`.
    2909
                mstore(0x00, 0x5821efa1)
    2910
                mstore(0x20, 0x60)
    2911
                mstore(0x40, 0xa0)
    2912
                mstore(0x60, p2)
    2913
                writeString(0x80, p0)
    2914
                writeString(0xc0, p1)
    2915
            }
    2916
            _sendLogPayload(0x1c, 0xe4);
    2917
            /// @solidity memory-safe-assembly
    2918
            assembly {
    2919
                mstore(0x00, m0)
    2920
                mstore(0x20, m1)
    2921
                mstore(0x40, m2)
    2922
                mstore(0x60, m3)
    2923
                mstore(0x80, m4)
    2924
                mstore(0xa0, m5)
    2925
                mstore(0xc0, m6)
    2926
                mstore(0xe0, m7)
    2927
            }
    2928
        }
    2929
    
                                                    
                                                
    2930
        function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {
    2931
            bytes32 m0;
    2932
            bytes32 m1;
    2933
            bytes32 m2;
    2934
            bytes32 m3;
    2935
            bytes32 m4;
    2936
            bytes32 m5;
    2937
            bytes32 m6;
    2938
            bytes32 m7;
    2939
            bytes32 m8;
    2940
            bytes32 m9;
    2941
            /// @solidity memory-safe-assembly
    2942
            assembly {
    2943
                function writeString(pos, w) {
    2944
                    let length := 0
    2945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2946
                    mstore(pos, length)
    2947
                    let shift := sub(256, shl(3, length))
    2948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2949
                }
    2950
                m0 := mload(0x00)
    2951
                m1 := mload(0x20)
    2952
                m2 := mload(0x40)
    2953
                m3 := mload(0x60)
    2954
                m4 := mload(0x80)
    2955
                m5 := mload(0xa0)
    2956
                m6 := mload(0xc0)
    2957
                m7 := mload(0xe0)
    2958
                m8 := mload(0x100)
    2959
                m9 := mload(0x120)
    2960
                // Selector of `log(string,string,string)`.
    2961
                mstore(0x00, 0x2ced7cef)
    2962
                mstore(0x20, 0x60)
    2963
                mstore(0x40, 0xa0)
    2964
                mstore(0x60, 0xe0)
    2965
                writeString(0x80, p0)
    2966
                writeString(0xc0, p1)
    2967
                writeString(0x100, p2)
    2968
            }
    2969
            _sendLogPayload(0x1c, 0x124);
    2970
            /// @solidity memory-safe-assembly
    2971
            assembly {
    2972
                mstore(0x00, m0)
    2973
                mstore(0x20, m1)
    2974
                mstore(0x40, m2)
    2975
                mstore(0x60, m3)
    2976
                mstore(0x80, m4)
    2977
                mstore(0xa0, m5)
    2978
                mstore(0xc0, m6)
    2979
                mstore(0xe0, m7)
    2980
                mstore(0x100, m8)
    2981
                mstore(0x120, m9)
    2982
            }
    2983
        }
    2984
    
                                                    
                                                
    2985
        function log(address p0, address p1, address p2, address p3) internal pure {
    2986
            bytes32 m0;
    2987
            bytes32 m1;
    2988
            bytes32 m2;
    2989
            bytes32 m3;
    2990
            bytes32 m4;
    2991
            /// @solidity memory-safe-assembly
    2992
            assembly {
    2993
                m0 := mload(0x00)
    2994
                m1 := mload(0x20)
    2995
                m2 := mload(0x40)
    2996
                m3 := mload(0x60)
    2997
                m4 := mload(0x80)
    2998
                // Selector of `log(address,address,address,address)`.
    2999
                mstore(0x00, 0x665bf134)
    3000
                mstore(0x20, p0)
    3001
                mstore(0x40, p1)
    3002
                mstore(0x60, p2)
    3003
                mstore(0x80, p3)
    3004
            }
    3005
            _sendLogPayload(0x1c, 0x84);
    3006
            /// @solidity memory-safe-assembly
    3007
            assembly {
    3008
                mstore(0x00, m0)
    3009
                mstore(0x20, m1)
    3010
                mstore(0x40, m2)
    3011
                mstore(0x60, m3)
    3012
                mstore(0x80, m4)
    3013
            }
    3014
        }
    3015
    
                                                    
                                                
    3016
        function log(address p0, address p1, address p2, bool p3) internal pure {
    3017
            bytes32 m0;
    3018
            bytes32 m1;
    3019
            bytes32 m2;
    3020
            bytes32 m3;
    3021
            bytes32 m4;
    3022
            /// @solidity memory-safe-assembly
    3023
            assembly {
    3024
                m0 := mload(0x00)
    3025
                m1 := mload(0x20)
    3026
                m2 := mload(0x40)
    3027
                m3 := mload(0x60)
    3028
                m4 := mload(0x80)
    3029
                // Selector of `log(address,address,address,bool)`.
    3030
                mstore(0x00, 0x0e378994)
    3031
                mstore(0x20, p0)
    3032
                mstore(0x40, p1)
    3033
                mstore(0x60, p2)
    3034
                mstore(0x80, p3)
    3035
            }
    3036
            _sendLogPayload(0x1c, 0x84);
    3037
            /// @solidity memory-safe-assembly
    3038
            assembly {
    3039
                mstore(0x00, m0)
    3040
                mstore(0x20, m1)
    3041
                mstore(0x40, m2)
    3042
                mstore(0x60, m3)
    3043
                mstore(0x80, m4)
    3044
            }
    3045
        }
    3046
    
                                                    
                                                
    3047
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    3048
            bytes32 m0;
    3049
            bytes32 m1;
    3050
            bytes32 m2;
    3051
            bytes32 m3;
    3052
            bytes32 m4;
    3053
            /// @solidity memory-safe-assembly
    3054
            assembly {
    3055
                m0 := mload(0x00)
    3056
                m1 := mload(0x20)
    3057
                m2 := mload(0x40)
    3058
                m3 := mload(0x60)
    3059
                m4 := mload(0x80)
    3060
                // Selector of `log(address,address,address,uint256)`.
    3061
                mstore(0x00, 0x94250d77)
    3062
                mstore(0x20, p0)
    3063
                mstore(0x40, p1)
    3064
                mstore(0x60, p2)
    3065
                mstore(0x80, p3)
    3066
            }
    3067
            _sendLogPayload(0x1c, 0x84);
    3068
            /// @solidity memory-safe-assembly
    3069
            assembly {
    3070
                mstore(0x00, m0)
    3071
                mstore(0x20, m1)
    3072
                mstore(0x40, m2)
    3073
                mstore(0x60, m3)
    3074
                mstore(0x80, m4)
    3075
            }
    3076
        }
    3077
    
                                                    
                                                
    3078
        function log(address p0, address p1, address p2, bytes32 p3) internal pure {
    3079
            bytes32 m0;
    3080
            bytes32 m1;
    3081
            bytes32 m2;
    3082
            bytes32 m3;
    3083
            bytes32 m4;
    3084
            bytes32 m5;
    3085
            bytes32 m6;
    3086
            /// @solidity memory-safe-assembly
    3087
            assembly {
    3088
                function writeString(pos, w) {
    3089
                    let length := 0
    3090
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3091
                    mstore(pos, length)
    3092
                    let shift := sub(256, shl(3, length))
    3093
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3094
                }
    3095
                m0 := mload(0x00)
    3096
                m1 := mload(0x20)
    3097
                m2 := mload(0x40)
    3098
                m3 := mload(0x60)
    3099
                m4 := mload(0x80)
    3100
                m5 := mload(0xa0)
    3101
                m6 := mload(0xc0)
    3102
                // Selector of `log(address,address,address,string)`.
    3103
                mstore(0x00, 0xf808da20)
    3104
                mstore(0x20, p0)
    3105
                mstore(0x40, p1)
    3106
                mstore(0x60, p2)
    3107
                mstore(0x80, 0x80)
    3108
                writeString(0xa0, p3)
    3109
            }
    3110
            _sendLogPayload(0x1c, 0xc4);
    3111
            /// @solidity memory-safe-assembly
    3112
            assembly {
    3113
                mstore(0x00, m0)
    3114
                mstore(0x20, m1)
    3115
                mstore(0x40, m2)
    3116
                mstore(0x60, m3)
    3117
                mstore(0x80, m4)
    3118
                mstore(0xa0, m5)
    3119
                mstore(0xc0, m6)
    3120
            }
    3121
        }
    3122
    
                                                    
                                                
    3123
        function log(address p0, address p1, bool p2, address p3) internal pure {
    3124
            bytes32 m0;
    3125
            bytes32 m1;
    3126
            bytes32 m2;
    3127
            bytes32 m3;
    3128
            bytes32 m4;
    3129
            /// @solidity memory-safe-assembly
    3130
            assembly {
    3131
                m0 := mload(0x00)
    3132
                m1 := mload(0x20)
    3133
                m2 := mload(0x40)
    3134
                m3 := mload(0x60)
    3135
                m4 := mload(0x80)
    3136
                // Selector of `log(address,address,bool,address)`.
    3137
                mstore(0x00, 0x9f1bc36e)
    3138
                mstore(0x20, p0)
    3139
                mstore(0x40, p1)
    3140
                mstore(0x60, p2)
    3141
                mstore(0x80, p3)
    3142
            }
    3143
            _sendLogPayload(0x1c, 0x84);
    3144
            /// @solidity memory-safe-assembly
    3145
            assembly {
    3146
                mstore(0x00, m0)
    3147
                mstore(0x20, m1)
    3148
                mstore(0x40, m2)
    3149
                mstore(0x60, m3)
    3150
                mstore(0x80, m4)
    3151
            }
    3152
        }
    3153
    
                                                    
                                                
    3154
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    3155
            bytes32 m0;
    3156
            bytes32 m1;
    3157
            bytes32 m2;
    3158
            bytes32 m3;
    3159
            bytes32 m4;
    3160
            /// @solidity memory-safe-assembly
    3161
            assembly {
    3162
                m0 := mload(0x00)
    3163
                m1 := mload(0x20)
    3164
                m2 := mload(0x40)
    3165
                m3 := mload(0x60)
    3166
                m4 := mload(0x80)
    3167
                // Selector of `log(address,address,bool,bool)`.
    3168
                mstore(0x00, 0x2cd4134a)
    3169
                mstore(0x20, p0)
    3170
                mstore(0x40, p1)
    3171
                mstore(0x60, p2)
    3172
                mstore(0x80, p3)
    3173
            }
    3174
            _sendLogPayload(0x1c, 0x84);
    3175
            /// @solidity memory-safe-assembly
    3176
            assembly {
    3177
                mstore(0x00, m0)
    3178
                mstore(0x20, m1)
    3179
                mstore(0x40, m2)
    3180
                mstore(0x60, m3)
    3181
                mstore(0x80, m4)
    3182
            }
    3183
        }
    3184
    
                                                    
                                                
    3185
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    3186
            bytes32 m0;
    3187
            bytes32 m1;
    3188
            bytes32 m2;
    3189
            bytes32 m3;
    3190
            bytes32 m4;
    3191
            /// @solidity memory-safe-assembly
    3192
            assembly {
    3193
                m0 := mload(0x00)
    3194
                m1 := mload(0x20)
    3195
                m2 := mload(0x40)
    3196
                m3 := mload(0x60)
    3197
                m4 := mload(0x80)
    3198
                // Selector of `log(address,address,bool,uint256)`.
    3199
                mstore(0x00, 0x3971e78c)
    3200
                mstore(0x20, p0)
    3201
                mstore(0x40, p1)
    3202
                mstore(0x60, p2)
    3203
                mstore(0x80, p3)
    3204
            }
    3205
            _sendLogPayload(0x1c, 0x84);
    3206
            /// @solidity memory-safe-assembly
    3207
            assembly {
    3208
                mstore(0x00, m0)
    3209
                mstore(0x20, m1)
    3210
                mstore(0x40, m2)
    3211
                mstore(0x60, m3)
    3212
                mstore(0x80, m4)
    3213
            }
    3214
        }
    3215
    
                                                    
                                                
    3216
        function log(address p0, address p1, bool p2, bytes32 p3) internal pure {
    3217
            bytes32 m0;
    3218
            bytes32 m1;
    3219
            bytes32 m2;
    3220
            bytes32 m3;
    3221
            bytes32 m4;
    3222
            bytes32 m5;
    3223
            bytes32 m6;
    3224
            /// @solidity memory-safe-assembly
    3225
            assembly {
    3226
                function writeString(pos, w) {
    3227
                    let length := 0
    3228
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3229
                    mstore(pos, length)
    3230
                    let shift := sub(256, shl(3, length))
    3231
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3232
                }
    3233
                m0 := mload(0x00)
    3234
                m1 := mload(0x20)
    3235
                m2 := mload(0x40)
    3236
                m3 := mload(0x60)
    3237
                m4 := mload(0x80)
    3238
                m5 := mload(0xa0)
    3239
                m6 := mload(0xc0)
    3240
                // Selector of `log(address,address,bool,string)`.
    3241
                mstore(0x00, 0xaa6540c8)
    3242
                mstore(0x20, p0)
    3243
                mstore(0x40, p1)
    3244
                mstore(0x60, p2)
    3245
                mstore(0x80, 0x80)
    3246
                writeString(0xa0, p3)
    3247
            }
    3248
            _sendLogPayload(0x1c, 0xc4);
    3249
            /// @solidity memory-safe-assembly
    3250
            assembly {
    3251
                mstore(0x00, m0)
    3252
                mstore(0x20, m1)
    3253
                mstore(0x40, m2)
    3254
                mstore(0x60, m3)
    3255
                mstore(0x80, m4)
    3256
                mstore(0xa0, m5)
    3257
                mstore(0xc0, m6)
    3258
            }
    3259
        }
    3260
    
                                                    
                                                
    3261
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    3262
            bytes32 m0;
    3263
            bytes32 m1;
    3264
            bytes32 m2;
    3265
            bytes32 m3;
    3266
            bytes32 m4;
    3267
            /// @solidity memory-safe-assembly
    3268
            assembly {
    3269
                m0 := mload(0x00)
    3270
                m1 := mload(0x20)
    3271
                m2 := mload(0x40)
    3272
                m3 := mload(0x60)
    3273
                m4 := mload(0x80)
    3274
                // Selector of `log(address,address,uint256,address)`.
    3275
                mstore(0x00, 0x8da6def5)
    3276
                mstore(0x20, p0)
    3277
                mstore(0x40, p1)
    3278
                mstore(0x60, p2)
    3279
                mstore(0x80, p3)
    3280
            }
    3281
            _sendLogPayload(0x1c, 0x84);
    3282
            /// @solidity memory-safe-assembly
    3283
            assembly {
    3284
                mstore(0x00, m0)
    3285
                mstore(0x20, m1)
    3286
                mstore(0x40, m2)
    3287
                mstore(0x60, m3)
    3288
                mstore(0x80, m4)
    3289
            }
    3290
        }
    3291
    
                                                    
                                                
    3292
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    3293
            bytes32 m0;
    3294
            bytes32 m1;
    3295
            bytes32 m2;
    3296
            bytes32 m3;
    3297
            bytes32 m4;
    3298
            /// @solidity memory-safe-assembly
    3299
            assembly {
    3300
                m0 := mload(0x00)
    3301
                m1 := mload(0x20)
    3302
                m2 := mload(0x40)
    3303
                m3 := mload(0x60)
    3304
                m4 := mload(0x80)
    3305
                // Selector of `log(address,address,uint256,bool)`.
    3306
                mstore(0x00, 0x9b4254e2)
    3307
                mstore(0x20, p0)
    3308
                mstore(0x40, p1)
    3309
                mstore(0x60, p2)
    3310
                mstore(0x80, p3)
    3311
            }
    3312
            _sendLogPayload(0x1c, 0x84);
    3313
            /// @solidity memory-safe-assembly
    3314
            assembly {
    3315
                mstore(0x00, m0)
    3316
                mstore(0x20, m1)
    3317
                mstore(0x40, m2)
    3318
                mstore(0x60, m3)
    3319
                mstore(0x80, m4)
    3320
            }
    3321
        }
    3322
    
                                                    
                                                
    3323
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    3324
            bytes32 m0;
    3325
            bytes32 m1;
    3326
            bytes32 m2;
    3327
            bytes32 m3;
    3328
            bytes32 m4;
    3329
            /// @solidity memory-safe-assembly
    3330
            assembly {
    3331
                m0 := mload(0x00)
    3332
                m1 := mload(0x20)
    3333
                m2 := mload(0x40)
    3334
                m3 := mload(0x60)
    3335
                m4 := mload(0x80)
    3336
                // Selector of `log(address,address,uint256,uint256)`.
    3337
                mstore(0x00, 0xbe553481)
    3338
                mstore(0x20, p0)
    3339
                mstore(0x40, p1)
    3340
                mstore(0x60, p2)
    3341
                mstore(0x80, p3)
    3342
            }
    3343
            _sendLogPayload(0x1c, 0x84);
    3344
            /// @solidity memory-safe-assembly
    3345
            assembly {
    3346
                mstore(0x00, m0)
    3347
                mstore(0x20, m1)
    3348
                mstore(0x40, m2)
    3349
                mstore(0x60, m3)
    3350
                mstore(0x80, m4)
    3351
            }
    3352
        }
    3353
    
                                                    
                                                
    3354
        function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {
    3355
            bytes32 m0;
    3356
            bytes32 m1;
    3357
            bytes32 m2;
    3358
            bytes32 m3;
    3359
            bytes32 m4;
    3360
            bytes32 m5;
    3361
            bytes32 m6;
    3362
            /// @solidity memory-safe-assembly
    3363
            assembly {
    3364
                function writeString(pos, w) {
    3365
                    let length := 0
    3366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3367
                    mstore(pos, length)
    3368
                    let shift := sub(256, shl(3, length))
    3369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3370
                }
    3371
                m0 := mload(0x00)
    3372
                m1 := mload(0x20)
    3373
                m2 := mload(0x40)
    3374
                m3 := mload(0x60)
    3375
                m4 := mload(0x80)
    3376
                m5 := mload(0xa0)
    3377
                m6 := mload(0xc0)
    3378
                // Selector of `log(address,address,uint256,string)`.
    3379
                mstore(0x00, 0xfdb4f990)
    3380
                mstore(0x20, p0)
    3381
                mstore(0x40, p1)
    3382
                mstore(0x60, p2)
    3383
                mstore(0x80, 0x80)
    3384
                writeString(0xa0, p3)
    3385
            }
    3386
            _sendLogPayload(0x1c, 0xc4);
    3387
            /// @solidity memory-safe-assembly
    3388
            assembly {
    3389
                mstore(0x00, m0)
    3390
                mstore(0x20, m1)
    3391
                mstore(0x40, m2)
    3392
                mstore(0x60, m3)
    3393
                mstore(0x80, m4)
    3394
                mstore(0xa0, m5)
    3395
                mstore(0xc0, m6)
    3396
            }
    3397
        }
    3398
    
                                                    
                                                
    3399
        function log(address p0, address p1, bytes32 p2, address p3) internal pure {
    3400
            bytes32 m0;
    3401
            bytes32 m1;
    3402
            bytes32 m2;
    3403
            bytes32 m3;
    3404
            bytes32 m4;
    3405
            bytes32 m5;
    3406
            bytes32 m6;
    3407
            /// @solidity memory-safe-assembly
    3408
            assembly {
    3409
                function writeString(pos, w) {
    3410
                    let length := 0
    3411
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3412
                    mstore(pos, length)
    3413
                    let shift := sub(256, shl(3, length))
    3414
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3415
                }
    3416
                m0 := mload(0x00)
    3417
                m1 := mload(0x20)
    3418
                m2 := mload(0x40)
    3419
                m3 := mload(0x60)
    3420
                m4 := mload(0x80)
    3421
                m5 := mload(0xa0)
    3422
                m6 := mload(0xc0)
    3423
                // Selector of `log(address,address,string,address)`.
    3424
                mstore(0x00, 0x8f736d16)
    3425
                mstore(0x20, p0)
    3426
                mstore(0x40, p1)
    3427
                mstore(0x60, 0x80)
    3428
                mstore(0x80, p3)
    3429
                writeString(0xa0, p2)
    3430
            }
    3431
            _sendLogPayload(0x1c, 0xc4);
    3432
            /// @solidity memory-safe-assembly
    3433
            assembly {
    3434
                mstore(0x00, m0)
    3435
                mstore(0x20, m1)
    3436
                mstore(0x40, m2)
    3437
                mstore(0x60, m3)
    3438
                mstore(0x80, m4)
    3439
                mstore(0xa0, m5)
    3440
                mstore(0xc0, m6)
    3441
            }
    3442
        }
    3443
    
                                                    
                                                
    3444
        function log(address p0, address p1, bytes32 p2, bool p3) internal pure {
    3445
            bytes32 m0;
    3446
            bytes32 m1;
    3447
            bytes32 m2;
    3448
            bytes32 m3;
    3449
            bytes32 m4;
    3450
            bytes32 m5;
    3451
            bytes32 m6;
    3452
            /// @solidity memory-safe-assembly
    3453
            assembly {
    3454
                function writeString(pos, w) {
    3455
                    let length := 0
    3456
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3457
                    mstore(pos, length)
    3458
                    let shift := sub(256, shl(3, length))
    3459
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3460
                }
    3461
                m0 := mload(0x00)
    3462
                m1 := mload(0x20)
    3463
                m2 := mload(0x40)
    3464
                m3 := mload(0x60)
    3465
                m4 := mload(0x80)
    3466
                m5 := mload(0xa0)
    3467
                m6 := mload(0xc0)
    3468
                // Selector of `log(address,address,string,bool)`.
    3469
                mstore(0x00, 0x6f1a594e)
    3470
                mstore(0x20, p0)
    3471
                mstore(0x40, p1)
    3472
                mstore(0x60, 0x80)
    3473
                mstore(0x80, p3)
    3474
                writeString(0xa0, p2)
    3475
            }
    3476
            _sendLogPayload(0x1c, 0xc4);
    3477
            /// @solidity memory-safe-assembly
    3478
            assembly {
    3479
                mstore(0x00, m0)
    3480
                mstore(0x20, m1)
    3481
                mstore(0x40, m2)
    3482
                mstore(0x60, m3)
    3483
                mstore(0x80, m4)
    3484
                mstore(0xa0, m5)
    3485
                mstore(0xc0, m6)
    3486
            }
    3487
        }
    3488
    
                                                    
                                                
    3489
        function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {
    3490
            bytes32 m0;
    3491
            bytes32 m1;
    3492
            bytes32 m2;
    3493
            bytes32 m3;
    3494
            bytes32 m4;
    3495
            bytes32 m5;
    3496
            bytes32 m6;
    3497
            /// @solidity memory-safe-assembly
    3498
            assembly {
    3499
                function writeString(pos, w) {
    3500
                    let length := 0
    3501
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3502
                    mstore(pos, length)
    3503
                    let shift := sub(256, shl(3, length))
    3504
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3505
                }
    3506
                m0 := mload(0x00)
    3507
                m1 := mload(0x20)
    3508
                m2 := mload(0x40)
    3509
                m3 := mload(0x60)
    3510
                m4 := mload(0x80)
    3511
                m5 := mload(0xa0)
    3512
                m6 := mload(0xc0)
    3513
                // Selector of `log(address,address,string,uint256)`.
    3514
                mstore(0x00, 0xef1cefe7)
    3515
                mstore(0x20, p0)
    3516
                mstore(0x40, p1)
    3517
                mstore(0x60, 0x80)
    3518
                mstore(0x80, p3)
    3519
                writeString(0xa0, p2)
    3520
            }
    3521
            _sendLogPayload(0x1c, 0xc4);
    3522
            /// @solidity memory-safe-assembly
    3523
            assembly {
    3524
                mstore(0x00, m0)
    3525
                mstore(0x20, m1)
    3526
                mstore(0x40, m2)
    3527
                mstore(0x60, m3)
    3528
                mstore(0x80, m4)
    3529
                mstore(0xa0, m5)
    3530
                mstore(0xc0, m6)
    3531
            }
    3532
        }
    3533
    
                                                    
                                                
    3534
        function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    3535
            bytes32 m0;
    3536
            bytes32 m1;
    3537
            bytes32 m2;
    3538
            bytes32 m3;
    3539
            bytes32 m4;
    3540
            bytes32 m5;
    3541
            bytes32 m6;
    3542
            bytes32 m7;
    3543
            bytes32 m8;
    3544
            /// @solidity memory-safe-assembly
    3545
            assembly {
    3546
                function writeString(pos, w) {
    3547
                    let length := 0
    3548
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3549
                    mstore(pos, length)
    3550
                    let shift := sub(256, shl(3, length))
    3551
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3552
                }
    3553
                m0 := mload(0x00)
    3554
                m1 := mload(0x20)
    3555
                m2 := mload(0x40)
    3556
                m3 := mload(0x60)
    3557
                m4 := mload(0x80)
    3558
                m5 := mload(0xa0)
    3559
                m6 := mload(0xc0)
    3560
                m7 := mload(0xe0)
    3561
                m8 := mload(0x100)
    3562
                // Selector of `log(address,address,string,string)`.
    3563
                mstore(0x00, 0x21bdaf25)
    3564
                mstore(0x20, p0)
    3565
                mstore(0x40, p1)
    3566
                mstore(0x60, 0x80)
    3567
                mstore(0x80, 0xc0)
    3568
                writeString(0xa0, p2)
    3569
                writeString(0xe0, p3)
    3570
            }
    3571
            _sendLogPayload(0x1c, 0x104);
    3572
            /// @solidity memory-safe-assembly
    3573
            assembly {
    3574
                mstore(0x00, m0)
    3575
                mstore(0x20, m1)
    3576
                mstore(0x40, m2)
    3577
                mstore(0x60, m3)
    3578
                mstore(0x80, m4)
    3579
                mstore(0xa0, m5)
    3580
                mstore(0xc0, m6)
    3581
                mstore(0xe0, m7)
    3582
                mstore(0x100, m8)
    3583
            }
    3584
        }
    3585
    
                                                    
                                                
    3586
        function log(address p0, bool p1, address p2, address p3) internal pure {
    3587
            bytes32 m0;
    3588
            bytes32 m1;
    3589
            bytes32 m2;
    3590
            bytes32 m3;
    3591
            bytes32 m4;
    3592
            /// @solidity memory-safe-assembly
    3593
            assembly {
    3594
                m0 := mload(0x00)
    3595
                m1 := mload(0x20)
    3596
                m2 := mload(0x40)
    3597
                m3 := mload(0x60)
    3598
                m4 := mload(0x80)
    3599
                // Selector of `log(address,bool,address,address)`.
    3600
                mstore(0x00, 0x660375dd)
    3601
                mstore(0x20, p0)
    3602
                mstore(0x40, p1)
    3603
                mstore(0x60, p2)
    3604
                mstore(0x80, p3)
    3605
            }
    3606
            _sendLogPayload(0x1c, 0x84);
    3607
            /// @solidity memory-safe-assembly
    3608
            assembly {
    3609
                mstore(0x00, m0)
    3610
                mstore(0x20, m1)
    3611
                mstore(0x40, m2)
    3612
                mstore(0x60, m3)
    3613
                mstore(0x80, m4)
    3614
            }
    3615
        }
    3616
    
                                                    
                                                
    3617
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    3618
            bytes32 m0;
    3619
            bytes32 m1;
    3620
            bytes32 m2;
    3621
            bytes32 m3;
    3622
            bytes32 m4;
    3623
            /// @solidity memory-safe-assembly
    3624
            assembly {
    3625
                m0 := mload(0x00)
    3626
                m1 := mload(0x20)
    3627
                m2 := mload(0x40)
    3628
                m3 := mload(0x60)
    3629
                m4 := mload(0x80)
    3630
                // Selector of `log(address,bool,address,bool)`.
    3631
                mstore(0x00, 0xa6f50b0f)
    3632
                mstore(0x20, p0)
    3633
                mstore(0x40, p1)
    3634
                mstore(0x60, p2)
    3635
                mstore(0x80, p3)
    3636
            }
    3637
            _sendLogPayload(0x1c, 0x84);
    3638
            /// @solidity memory-safe-assembly
    3639
            assembly {
    3640
                mstore(0x00, m0)
    3641
                mstore(0x20, m1)
    3642
                mstore(0x40, m2)
    3643
                mstore(0x60, m3)
    3644
                mstore(0x80, m4)
    3645
            }
    3646
        }
    3647
    
                                                    
                                                
    3648
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    3649
            bytes32 m0;
    3650
            bytes32 m1;
    3651
            bytes32 m2;
    3652
            bytes32 m3;
    3653
            bytes32 m4;
    3654
            /// @solidity memory-safe-assembly
    3655
            assembly {
    3656
                m0 := mload(0x00)
    3657
                m1 := mload(0x20)
    3658
                m2 := mload(0x40)
    3659
                m3 := mload(0x60)
    3660
                m4 := mload(0x80)
    3661
                // Selector of `log(address,bool,address,uint256)`.
    3662
                mstore(0x00, 0xa75c59de)
    3663
                mstore(0x20, p0)
    3664
                mstore(0x40, p1)
    3665
                mstore(0x60, p2)
    3666
                mstore(0x80, p3)
    3667
            }
    3668
            _sendLogPayload(0x1c, 0x84);
    3669
            /// @solidity memory-safe-assembly
    3670
            assembly {
    3671
                mstore(0x00, m0)
    3672
                mstore(0x20, m1)
    3673
                mstore(0x40, m2)
    3674
                mstore(0x60, m3)
    3675
                mstore(0x80, m4)
    3676
            }
    3677
        }
    3678
    
                                                    
                                                
    3679
        function log(address p0, bool p1, address p2, bytes32 p3) internal pure {
    3680
            bytes32 m0;
    3681
            bytes32 m1;
    3682
            bytes32 m2;
    3683
            bytes32 m3;
    3684
            bytes32 m4;
    3685
            bytes32 m5;
    3686
            bytes32 m6;
    3687
            /// @solidity memory-safe-assembly
    3688
            assembly {
    3689
                function writeString(pos, w) {
    3690
                    let length := 0
    3691
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3692
                    mstore(pos, length)
    3693
                    let shift := sub(256, shl(3, length))
    3694
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3695
                }
    3696
                m0 := mload(0x00)
    3697
                m1 := mload(0x20)
    3698
                m2 := mload(0x40)
    3699
                m3 := mload(0x60)
    3700
                m4 := mload(0x80)
    3701
                m5 := mload(0xa0)
    3702
                m6 := mload(0xc0)
    3703
                // Selector of `log(address,bool,address,string)`.
    3704
                mstore(0x00, 0x2dd778e6)
    3705
                mstore(0x20, p0)
    3706
                mstore(0x40, p1)
    3707
                mstore(0x60, p2)
    3708
                mstore(0x80, 0x80)
    3709
                writeString(0xa0, p3)
    3710
            }
    3711
            _sendLogPayload(0x1c, 0xc4);
    3712
            /// @solidity memory-safe-assembly
    3713
            assembly {
    3714
                mstore(0x00, m0)
    3715
                mstore(0x20, m1)
    3716
                mstore(0x40, m2)
    3717
                mstore(0x60, m3)
    3718
                mstore(0x80, m4)
    3719
                mstore(0xa0, m5)
    3720
                mstore(0xc0, m6)
    3721
            }
    3722
        }
    3723
    
                                                    
                                                
    3724
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    3725
            bytes32 m0;
    3726
            bytes32 m1;
    3727
            bytes32 m2;
    3728
            bytes32 m3;
    3729
            bytes32 m4;
    3730
            /// @solidity memory-safe-assembly
    3731
            assembly {
    3732
                m0 := mload(0x00)
    3733
                m1 := mload(0x20)
    3734
                m2 := mload(0x40)
    3735
                m3 := mload(0x60)
    3736
                m4 := mload(0x80)
    3737
                // Selector of `log(address,bool,bool,address)`.
    3738
                mstore(0x00, 0xcf394485)
    3739
                mstore(0x20, p0)
    3740
                mstore(0x40, p1)
    3741
                mstore(0x60, p2)
    3742
                mstore(0x80, p3)
    3743
            }
    3744
            _sendLogPayload(0x1c, 0x84);
    3745
            /// @solidity memory-safe-assembly
    3746
            assembly {
    3747
                mstore(0x00, m0)
    3748
                mstore(0x20, m1)
    3749
                mstore(0x40, m2)
    3750
                mstore(0x60, m3)
    3751
                mstore(0x80, m4)
    3752
            }
    3753
        }
    3754
    
                                                    
                                                
    3755
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    3756
            bytes32 m0;
    3757
            bytes32 m1;
    3758
            bytes32 m2;
    3759
            bytes32 m3;
    3760
            bytes32 m4;
    3761
            /// @solidity memory-safe-assembly
    3762
            assembly {
    3763
                m0 := mload(0x00)
    3764
                m1 := mload(0x20)
    3765
                m2 := mload(0x40)
    3766
                m3 := mload(0x60)
    3767
                m4 := mload(0x80)
    3768
                // Selector of `log(address,bool,bool,bool)`.
    3769
                mstore(0x00, 0xcac43479)
    3770
                mstore(0x20, p0)
    3771
                mstore(0x40, p1)
    3772
                mstore(0x60, p2)
    3773
                mstore(0x80, p3)
    3774
            }
    3775
            _sendLogPayload(0x1c, 0x84);
    3776
            /// @solidity memory-safe-assembly
    3777
            assembly {
    3778
                mstore(0x00, m0)
    3779
                mstore(0x20, m1)
    3780
                mstore(0x40, m2)
    3781
                mstore(0x60, m3)
    3782
                mstore(0x80, m4)
    3783
            }
    3784
        }
    3785
    
                                                    
                                                
    3786
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    3787
            bytes32 m0;
    3788
            bytes32 m1;
    3789
            bytes32 m2;
    3790
            bytes32 m3;
    3791
            bytes32 m4;
    3792
            /// @solidity memory-safe-assembly
    3793
            assembly {
    3794
                m0 := mload(0x00)
    3795
                m1 := mload(0x20)
    3796
                m2 := mload(0x40)
    3797
                m3 := mload(0x60)
    3798
                m4 := mload(0x80)
    3799
                // Selector of `log(address,bool,bool,uint256)`.
    3800
                mstore(0x00, 0x8c4e5de6)
    3801
                mstore(0x20, p0)
    3802
                mstore(0x40, p1)
    3803
                mstore(0x60, p2)
    3804
                mstore(0x80, p3)
    3805
            }
    3806
            _sendLogPayload(0x1c, 0x84);
    3807
            /// @solidity memory-safe-assembly
    3808
            assembly {
    3809
                mstore(0x00, m0)
    3810
                mstore(0x20, m1)
    3811
                mstore(0x40, m2)
    3812
                mstore(0x60, m3)
    3813
                mstore(0x80, m4)
    3814
            }
    3815
        }
    3816
    
                                                    
                                                
    3817
        function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {
    3818
            bytes32 m0;
    3819
            bytes32 m1;
    3820
            bytes32 m2;
    3821
            bytes32 m3;
    3822
            bytes32 m4;
    3823
            bytes32 m5;
    3824
            bytes32 m6;
    3825
            /// @solidity memory-safe-assembly
    3826
            assembly {
    3827
                function writeString(pos, w) {
    3828
                    let length := 0
    3829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3830
                    mstore(pos, length)
    3831
                    let shift := sub(256, shl(3, length))
    3832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3833
                }
    3834
                m0 := mload(0x00)
    3835
                m1 := mload(0x20)
    3836
                m2 := mload(0x40)
    3837
                m3 := mload(0x60)
    3838
                m4 := mload(0x80)
    3839
                m5 := mload(0xa0)
    3840
                m6 := mload(0xc0)
    3841
                // Selector of `log(address,bool,bool,string)`.
    3842
                mstore(0x00, 0xdfc4a2e8)
    3843
                mstore(0x20, p0)
    3844
                mstore(0x40, p1)
    3845
                mstore(0x60, p2)
    3846
                mstore(0x80, 0x80)
    3847
                writeString(0xa0, p3)
    3848
            }
    3849
            _sendLogPayload(0x1c, 0xc4);
    3850
            /// @solidity memory-safe-assembly
    3851
            assembly {
    3852
                mstore(0x00, m0)
    3853
                mstore(0x20, m1)
    3854
                mstore(0x40, m2)
    3855
                mstore(0x60, m3)
    3856
                mstore(0x80, m4)
    3857
                mstore(0xa0, m5)
    3858
                mstore(0xc0, m6)
    3859
            }
    3860
        }
    3861
    
                                                    
                                                
    3862
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    3863
            bytes32 m0;
    3864
            bytes32 m1;
    3865
            bytes32 m2;
    3866
            bytes32 m3;
    3867
            bytes32 m4;
    3868
            /// @solidity memory-safe-assembly
    3869
            assembly {
    3870
                m0 := mload(0x00)
    3871
                m1 := mload(0x20)
    3872
                m2 := mload(0x40)
    3873
                m3 := mload(0x60)
    3874
                m4 := mload(0x80)
    3875
                // Selector of `log(address,bool,uint256,address)`.
    3876
                mstore(0x00, 0xccf790a1)
    3877
                mstore(0x20, p0)
    3878
                mstore(0x40, p1)
    3879
                mstore(0x60, p2)
    3880
                mstore(0x80, p3)
    3881
            }
    3882
            _sendLogPayload(0x1c, 0x84);
    3883
            /// @solidity memory-safe-assembly
    3884
            assembly {
    3885
                mstore(0x00, m0)
    3886
                mstore(0x20, m1)
    3887
                mstore(0x40, m2)
    3888
                mstore(0x60, m3)
    3889
                mstore(0x80, m4)
    3890
            }
    3891
        }
    3892
    
                                                    
                                                
    3893
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    3894
            bytes32 m0;
    3895
            bytes32 m1;
    3896
            bytes32 m2;
    3897
            bytes32 m3;
    3898
            bytes32 m4;
    3899
            /// @solidity memory-safe-assembly
    3900
            assembly {
    3901
                m0 := mload(0x00)
    3902
                m1 := mload(0x20)
    3903
                m2 := mload(0x40)
    3904
                m3 := mload(0x60)
    3905
                m4 := mload(0x80)
    3906
                // Selector of `log(address,bool,uint256,bool)`.
    3907
                mstore(0x00, 0xc4643e20)
    3908
                mstore(0x20, p0)
    3909
                mstore(0x40, p1)
    3910
                mstore(0x60, p2)
    3911
                mstore(0x80, p3)
    3912
            }
    3913
            _sendLogPayload(0x1c, 0x84);
    3914
            /// @solidity memory-safe-assembly
    3915
            assembly {
    3916
                mstore(0x00, m0)
    3917
                mstore(0x20, m1)
    3918
                mstore(0x40, m2)
    3919
                mstore(0x60, m3)
    3920
                mstore(0x80, m4)
    3921
            }
    3922
        }
    3923
    
                                                    
                                                
    3924
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    3925
            bytes32 m0;
    3926
            bytes32 m1;
    3927
            bytes32 m2;
    3928
            bytes32 m3;
    3929
            bytes32 m4;
    3930
            /// @solidity memory-safe-assembly
    3931
            assembly {
    3932
                m0 := mload(0x00)
    3933
                m1 := mload(0x20)
    3934
                m2 := mload(0x40)
    3935
                m3 := mload(0x60)
    3936
                m4 := mload(0x80)
    3937
                // Selector of `log(address,bool,uint256,uint256)`.
    3938
                mstore(0x00, 0x386ff5f4)
    3939
                mstore(0x20, p0)
    3940
                mstore(0x40, p1)
    3941
                mstore(0x60, p2)
    3942
                mstore(0x80, p3)
    3943
            }
    3944
            _sendLogPayload(0x1c, 0x84);
    3945
            /// @solidity memory-safe-assembly
    3946
            assembly {
    3947
                mstore(0x00, m0)
    3948
                mstore(0x20, m1)
    3949
                mstore(0x40, m2)
    3950
                mstore(0x60, m3)
    3951
                mstore(0x80, m4)
    3952
            }
    3953
        }
    3954
    
                                                    
                                                
    3955
        function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    3956
            bytes32 m0;
    3957
            bytes32 m1;
    3958
            bytes32 m2;
    3959
            bytes32 m3;
    3960
            bytes32 m4;
    3961
            bytes32 m5;
    3962
            bytes32 m6;
    3963
            /// @solidity memory-safe-assembly
    3964
            assembly {
    3965
                function writeString(pos, w) {
    3966
                    let length := 0
    3967
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3968
                    mstore(pos, length)
    3969
                    let shift := sub(256, shl(3, length))
    3970
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3971
                }
    3972
                m0 := mload(0x00)
    3973
                m1 := mload(0x20)
    3974
                m2 := mload(0x40)
    3975
                m3 := mload(0x60)
    3976
                m4 := mload(0x80)
    3977
                m5 := mload(0xa0)
    3978
                m6 := mload(0xc0)
    3979
                // Selector of `log(address,bool,uint256,string)`.
    3980
                mstore(0x00, 0x0aa6cfad)
    3981
                mstore(0x20, p0)
    3982
                mstore(0x40, p1)
    3983
                mstore(0x60, p2)
    3984
                mstore(0x80, 0x80)
    3985
                writeString(0xa0, p3)
    3986
            }
    3987
            _sendLogPayload(0x1c, 0xc4);
    3988
            /// @solidity memory-safe-assembly
    3989
            assembly {
    3990
                mstore(0x00, m0)
    3991
                mstore(0x20, m1)
    3992
                mstore(0x40, m2)
    3993
                mstore(0x60, m3)
    3994
                mstore(0x80, m4)
    3995
                mstore(0xa0, m5)
    3996
                mstore(0xc0, m6)
    3997
            }
    3998
        }
    3999
    
                                                    
                                                
    4000
        function log(address p0, bool p1, bytes32 p2, address p3) internal pure {
    4001
            bytes32 m0;
    4002
            bytes32 m1;
    4003
            bytes32 m2;
    4004
            bytes32 m3;
    4005
            bytes32 m4;
    4006
            bytes32 m5;
    4007
            bytes32 m6;
    4008
            /// @solidity memory-safe-assembly
    4009
            assembly {
    4010
                function writeString(pos, w) {
    4011
                    let length := 0
    4012
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4013
                    mstore(pos, length)
    4014
                    let shift := sub(256, shl(3, length))
    4015
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4016
                }
    4017
                m0 := mload(0x00)
    4018
                m1 := mload(0x20)
    4019
                m2 := mload(0x40)
    4020
                m3 := mload(0x60)
    4021
                m4 := mload(0x80)
    4022
                m5 := mload(0xa0)
    4023
                m6 := mload(0xc0)
    4024
                // Selector of `log(address,bool,string,address)`.
    4025
                mstore(0x00, 0x19fd4956)
    4026
                mstore(0x20, p0)
    4027
                mstore(0x40, p1)
    4028
                mstore(0x60, 0x80)
    4029
                mstore(0x80, p3)
    4030
                writeString(0xa0, p2)
    4031
            }
    4032
            _sendLogPayload(0x1c, 0xc4);
    4033
            /// @solidity memory-safe-assembly
    4034
            assembly {
    4035
                mstore(0x00, m0)
    4036
                mstore(0x20, m1)
    4037
                mstore(0x40, m2)
    4038
                mstore(0x60, m3)
    4039
                mstore(0x80, m4)
    4040
                mstore(0xa0, m5)
    4041
                mstore(0xc0, m6)
    4042
            }
    4043
        }
    4044
    
                                                    
                                                
    4045
        function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {
    4046
            bytes32 m0;
    4047
            bytes32 m1;
    4048
            bytes32 m2;
    4049
            bytes32 m3;
    4050
            bytes32 m4;
    4051
            bytes32 m5;
    4052
            bytes32 m6;
    4053
            /// @solidity memory-safe-assembly
    4054
            assembly {
    4055
                function writeString(pos, w) {
    4056
                    let length := 0
    4057
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4058
                    mstore(pos, length)
    4059
                    let shift := sub(256, shl(3, length))
    4060
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4061
                }
    4062
                m0 := mload(0x00)
    4063
                m1 := mload(0x20)
    4064
                m2 := mload(0x40)
    4065
                m3 := mload(0x60)
    4066
                m4 := mload(0x80)
    4067
                m5 := mload(0xa0)
    4068
                m6 := mload(0xc0)
    4069
                // Selector of `log(address,bool,string,bool)`.
    4070
                mstore(0x00, 0x50ad461d)
    4071
                mstore(0x20, p0)
    4072
                mstore(0x40, p1)
    4073
                mstore(0x60, 0x80)
    4074
                mstore(0x80, p3)
    4075
                writeString(0xa0, p2)
    4076
            }
    4077
            _sendLogPayload(0x1c, 0xc4);
    4078
            /// @solidity memory-safe-assembly
    4079
            assembly {
    4080
                mstore(0x00, m0)
    4081
                mstore(0x20, m1)
    4082
                mstore(0x40, m2)
    4083
                mstore(0x60, m3)
    4084
                mstore(0x80, m4)
    4085
                mstore(0xa0, m5)
    4086
                mstore(0xc0, m6)
    4087
            }
    4088
        }
    4089
    
                                                    
                                                
    4090
        function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    4091
            bytes32 m0;
    4092
            bytes32 m1;
    4093
            bytes32 m2;
    4094
            bytes32 m3;
    4095
            bytes32 m4;
    4096
            bytes32 m5;
    4097
            bytes32 m6;
    4098
            /// @solidity memory-safe-assembly
    4099
            assembly {
    4100
                function writeString(pos, w) {
    4101
                    let length := 0
    4102
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4103
                    mstore(pos, length)
    4104
                    let shift := sub(256, shl(3, length))
    4105
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4106
                }
    4107
                m0 := mload(0x00)
    4108
                m1 := mload(0x20)
    4109
                m2 := mload(0x40)
    4110
                m3 := mload(0x60)
    4111
                m4 := mload(0x80)
    4112
                m5 := mload(0xa0)
    4113
                m6 := mload(0xc0)
    4114
                // Selector of `log(address,bool,string,uint256)`.
    4115
                mstore(0x00, 0x80e6a20b)
    4116
                mstore(0x20, p0)
    4117
                mstore(0x40, p1)
    4118
                mstore(0x60, 0x80)
    4119
                mstore(0x80, p3)
    4120
                writeString(0xa0, p2)
    4121
            }
    4122
            _sendLogPayload(0x1c, 0xc4);
    4123
            /// @solidity memory-safe-assembly
    4124
            assembly {
    4125
                mstore(0x00, m0)
    4126
                mstore(0x20, m1)
    4127
                mstore(0x40, m2)
    4128
                mstore(0x60, m3)
    4129
                mstore(0x80, m4)
    4130
                mstore(0xa0, m5)
    4131
                mstore(0xc0, m6)
    4132
            }
    4133
        }
    4134
    
                                                    
                                                
    4135
        function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    4136
            bytes32 m0;
    4137
            bytes32 m1;
    4138
            bytes32 m2;
    4139
            bytes32 m3;
    4140
            bytes32 m4;
    4141
            bytes32 m5;
    4142
            bytes32 m6;
    4143
            bytes32 m7;
    4144
            bytes32 m8;
    4145
            /// @solidity memory-safe-assembly
    4146
            assembly {
    4147
                function writeString(pos, w) {
    4148
                    let length := 0
    4149
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4150
                    mstore(pos, length)
    4151
                    let shift := sub(256, shl(3, length))
    4152
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4153
                }
    4154
                m0 := mload(0x00)
    4155
                m1 := mload(0x20)
    4156
                m2 := mload(0x40)
    4157
                m3 := mload(0x60)
    4158
                m4 := mload(0x80)
    4159
                m5 := mload(0xa0)
    4160
                m6 := mload(0xc0)
    4161
                m7 := mload(0xe0)
    4162
                m8 := mload(0x100)
    4163
                // Selector of `log(address,bool,string,string)`.
    4164
                mstore(0x00, 0x475c5c33)
    4165
                mstore(0x20, p0)
    4166
                mstore(0x40, p1)
    4167
                mstore(0x60, 0x80)
    4168
                mstore(0x80, 0xc0)
    4169
                writeString(0xa0, p2)
    4170
                writeString(0xe0, p3)
    4171
            }
    4172
            _sendLogPayload(0x1c, 0x104);
    4173
            /// @solidity memory-safe-assembly
    4174
            assembly {
    4175
                mstore(0x00, m0)
    4176
                mstore(0x20, m1)
    4177
                mstore(0x40, m2)
    4178
                mstore(0x60, m3)
    4179
                mstore(0x80, m4)
    4180
                mstore(0xa0, m5)
    4181
                mstore(0xc0, m6)
    4182
                mstore(0xe0, m7)
    4183
                mstore(0x100, m8)
    4184
            }
    4185
        }
    4186
    
                                                    
                                                
    4187
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    4188
            bytes32 m0;
    4189
            bytes32 m1;
    4190
            bytes32 m2;
    4191
            bytes32 m3;
    4192
            bytes32 m4;
    4193
            /// @solidity memory-safe-assembly
    4194
            assembly {
    4195
                m0 := mload(0x00)
    4196
                m1 := mload(0x20)
    4197
                m2 := mload(0x40)
    4198
                m3 := mload(0x60)
    4199
                m4 := mload(0x80)
    4200
                // Selector of `log(address,uint256,address,address)`.
    4201
                mstore(0x00, 0x478d1c62)
    4202
                mstore(0x20, p0)
    4203
                mstore(0x40, p1)
    4204
                mstore(0x60, p2)
    4205
                mstore(0x80, p3)
    4206
            }
    4207
            _sendLogPayload(0x1c, 0x84);
    4208
            /// @solidity memory-safe-assembly
    4209
            assembly {
    4210
                mstore(0x00, m0)
    4211
                mstore(0x20, m1)
    4212
                mstore(0x40, m2)
    4213
                mstore(0x60, m3)
    4214
                mstore(0x80, m4)
    4215
            }
    4216
        }
    4217
    
                                                    
                                                
    4218
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    4219
            bytes32 m0;
    4220
            bytes32 m1;
    4221
            bytes32 m2;
    4222
            bytes32 m3;
    4223
            bytes32 m4;
    4224
            /// @solidity memory-safe-assembly
    4225
            assembly {
    4226
                m0 := mload(0x00)
    4227
                m1 := mload(0x20)
    4228
                m2 := mload(0x40)
    4229
                m3 := mload(0x60)
    4230
                m4 := mload(0x80)
    4231
                // Selector of `log(address,uint256,address,bool)`.
    4232
                mstore(0x00, 0xa1bcc9b3)
    4233
                mstore(0x20, p0)
    4234
                mstore(0x40, p1)
    4235
                mstore(0x60, p2)
    4236
                mstore(0x80, p3)
    4237
            }
    4238
            _sendLogPayload(0x1c, 0x84);
    4239
            /// @solidity memory-safe-assembly
    4240
            assembly {
    4241
                mstore(0x00, m0)
    4242
                mstore(0x20, m1)
    4243
                mstore(0x40, m2)
    4244
                mstore(0x60, m3)
    4245
                mstore(0x80, m4)
    4246
            }
    4247
        }
    4248
    
                                                    
                                                
    4249
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    4250
            bytes32 m0;
    4251
            bytes32 m1;
    4252
            bytes32 m2;
    4253
            bytes32 m3;
    4254
            bytes32 m4;
    4255
            /// @solidity memory-safe-assembly
    4256
            assembly {
    4257
                m0 := mload(0x00)
    4258
                m1 := mload(0x20)
    4259
                m2 := mload(0x40)
    4260
                m3 := mload(0x60)
    4261
                m4 := mload(0x80)
    4262
                // Selector of `log(address,uint256,address,uint256)`.
    4263
                mstore(0x00, 0x100f650e)
    4264
                mstore(0x20, p0)
    4265
                mstore(0x40, p1)
    4266
                mstore(0x60, p2)
    4267
                mstore(0x80, p3)
    4268
            }
    4269
            _sendLogPayload(0x1c, 0x84);
    4270
            /// @solidity memory-safe-assembly
    4271
            assembly {
    4272
                mstore(0x00, m0)
    4273
                mstore(0x20, m1)
    4274
                mstore(0x40, m2)
    4275
                mstore(0x60, m3)
    4276
                mstore(0x80, m4)
    4277
            }
    4278
        }
    4279
    
                                                    
                                                
    4280
        function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {
    4281
            bytes32 m0;
    4282
            bytes32 m1;
    4283
            bytes32 m2;
    4284
            bytes32 m3;
    4285
            bytes32 m4;
    4286
            bytes32 m5;
    4287
            bytes32 m6;
    4288
            /// @solidity memory-safe-assembly
    4289
            assembly {
    4290
                function writeString(pos, w) {
    4291
                    let length := 0
    4292
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4293
                    mstore(pos, length)
    4294
                    let shift := sub(256, shl(3, length))
    4295
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4296
                }
    4297
                m0 := mload(0x00)
    4298
                m1 := mload(0x20)
    4299
                m2 := mload(0x40)
    4300
                m3 := mload(0x60)
    4301
                m4 := mload(0x80)
    4302
                m5 := mload(0xa0)
    4303
                m6 := mload(0xc0)
    4304
                // Selector of `log(address,uint256,address,string)`.
    4305
                mstore(0x00, 0x1da986ea)
    4306
                mstore(0x20, p0)
    4307
                mstore(0x40, p1)
    4308
                mstore(0x60, p2)
    4309
                mstore(0x80, 0x80)
    4310
                writeString(0xa0, p3)
    4311
            }
    4312
            _sendLogPayload(0x1c, 0xc4);
    4313
            /// @solidity memory-safe-assembly
    4314
            assembly {
    4315
                mstore(0x00, m0)
    4316
                mstore(0x20, m1)
    4317
                mstore(0x40, m2)
    4318
                mstore(0x60, m3)
    4319
                mstore(0x80, m4)
    4320
                mstore(0xa0, m5)
    4321
                mstore(0xc0, m6)
    4322
            }
    4323
        }
    4324
    
                                                    
                                                
    4325
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    4326
            bytes32 m0;
    4327
            bytes32 m1;
    4328
            bytes32 m2;
    4329
            bytes32 m3;
    4330
            bytes32 m4;
    4331
            /// @solidity memory-safe-assembly
    4332
            assembly {
    4333
                m0 := mload(0x00)
    4334
                m1 := mload(0x20)
    4335
                m2 := mload(0x40)
    4336
                m3 := mload(0x60)
    4337
                m4 := mload(0x80)
    4338
                // Selector of `log(address,uint256,bool,address)`.
    4339
                mstore(0x00, 0xa31bfdcc)
    4340
                mstore(0x20, p0)
    4341
                mstore(0x40, p1)
    4342
                mstore(0x60, p2)
    4343
                mstore(0x80, p3)
    4344
            }
    4345
            _sendLogPayload(0x1c, 0x84);
    4346
            /// @solidity memory-safe-assembly
    4347
            assembly {
    4348
                mstore(0x00, m0)
    4349
                mstore(0x20, m1)
    4350
                mstore(0x40, m2)
    4351
                mstore(0x60, m3)
    4352
                mstore(0x80, m4)
    4353
            }
    4354
        }
    4355
    
                                                    
                                                
    4356
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    4357
            bytes32 m0;
    4358
            bytes32 m1;
    4359
            bytes32 m2;
    4360
            bytes32 m3;
    4361
            bytes32 m4;
    4362
            /// @solidity memory-safe-assembly
    4363
            assembly {
    4364
                m0 := mload(0x00)
    4365
                m1 := mload(0x20)
    4366
                m2 := mload(0x40)
    4367
                m3 := mload(0x60)
    4368
                m4 := mload(0x80)
    4369
                // Selector of `log(address,uint256,bool,bool)`.
    4370
                mstore(0x00, 0x3bf5e537)
    4371
                mstore(0x20, p0)
    4372
                mstore(0x40, p1)
    4373
                mstore(0x60, p2)
    4374
                mstore(0x80, p3)
    4375
            }
    4376
            _sendLogPayload(0x1c, 0x84);
    4377
            /// @solidity memory-safe-assembly
    4378
            assembly {
    4379
                mstore(0x00, m0)
    4380
                mstore(0x20, m1)
    4381
                mstore(0x40, m2)
    4382
                mstore(0x60, m3)
    4383
                mstore(0x80, m4)
    4384
            }
    4385
        }
    4386
    
                                                    
                                                
    4387
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    4388
            bytes32 m0;
    4389
            bytes32 m1;
    4390
            bytes32 m2;
    4391
            bytes32 m3;
    4392
            bytes32 m4;
    4393
            /// @solidity memory-safe-assembly
    4394
            assembly {
    4395
                m0 := mload(0x00)
    4396
                m1 := mload(0x20)
    4397
                m2 := mload(0x40)
    4398
                m3 := mload(0x60)
    4399
                m4 := mload(0x80)
    4400
                // Selector of `log(address,uint256,bool,uint256)`.
    4401
                mstore(0x00, 0x22f6b999)
    4402
                mstore(0x20, p0)
    4403
                mstore(0x40, p1)
    4404
                mstore(0x60, p2)
    4405
                mstore(0x80, p3)
    4406
            }
    4407
            _sendLogPayload(0x1c, 0x84);
    4408
            /// @solidity memory-safe-assembly
    4409
            assembly {
    4410
                mstore(0x00, m0)
    4411
                mstore(0x20, m1)
    4412
                mstore(0x40, m2)
    4413
                mstore(0x60, m3)
    4414
                mstore(0x80, m4)
    4415
            }
    4416
        }
    4417
    
                                                    
                                                
    4418
        function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    4419
            bytes32 m0;
    4420
            bytes32 m1;
    4421
            bytes32 m2;
    4422
            bytes32 m3;
    4423
            bytes32 m4;
    4424
            bytes32 m5;
    4425
            bytes32 m6;
    4426
            /// @solidity memory-safe-assembly
    4427
            assembly {
    4428
                function writeString(pos, w) {
    4429
                    let length := 0
    4430
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4431
                    mstore(pos, length)
    4432
                    let shift := sub(256, shl(3, length))
    4433
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4434
                }
    4435
                m0 := mload(0x00)
    4436
                m1 := mload(0x20)
    4437
                m2 := mload(0x40)
    4438
                m3 := mload(0x60)
    4439
                m4 := mload(0x80)
    4440
                m5 := mload(0xa0)
    4441
                m6 := mload(0xc0)
    4442
                // Selector of `log(address,uint256,bool,string)`.
    4443
                mstore(0x00, 0xc5ad85f9)
    4444
                mstore(0x20, p0)
    4445
                mstore(0x40, p1)
    4446
                mstore(0x60, p2)
    4447
                mstore(0x80, 0x80)
    4448
                writeString(0xa0, p3)
    4449
            }
    4450
            _sendLogPayload(0x1c, 0xc4);
    4451
            /// @solidity memory-safe-assembly
    4452
            assembly {
    4453
                mstore(0x00, m0)
    4454
                mstore(0x20, m1)
    4455
                mstore(0x40, m2)
    4456
                mstore(0x60, m3)
    4457
                mstore(0x80, m4)
    4458
                mstore(0xa0, m5)
    4459
                mstore(0xc0, m6)
    4460
            }
    4461
        }
    4462
    
                                                    
                                                
    4463
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    4464
            bytes32 m0;
    4465
            bytes32 m1;
    4466
            bytes32 m2;
    4467
            bytes32 m3;
    4468
            bytes32 m4;
    4469
            /// @solidity memory-safe-assembly
    4470
            assembly {
    4471
                m0 := mload(0x00)
    4472
                m1 := mload(0x20)
    4473
                m2 := mload(0x40)
    4474
                m3 := mload(0x60)
    4475
                m4 := mload(0x80)
    4476
                // Selector of `log(address,uint256,uint256,address)`.
    4477
                mstore(0x00, 0x20e3984d)
    4478
                mstore(0x20, p0)
    4479
                mstore(0x40, p1)
    4480
                mstore(0x60, p2)
    4481
                mstore(0x80, p3)
    4482
            }
    4483
            _sendLogPayload(0x1c, 0x84);
    4484
            /// @solidity memory-safe-assembly
    4485
            assembly {
    4486
                mstore(0x00, m0)
    4487
                mstore(0x20, m1)
    4488
                mstore(0x40, m2)
    4489
                mstore(0x60, m3)
    4490
                mstore(0x80, m4)
    4491
            }
    4492
        }
    4493
    
                                                    
                                                
    4494
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    4495
            bytes32 m0;
    4496
            bytes32 m1;
    4497
            bytes32 m2;
    4498
            bytes32 m3;
    4499
            bytes32 m4;
    4500
            /// @solidity memory-safe-assembly
    4501
            assembly {
    4502
                m0 := mload(0x00)
    4503
                m1 := mload(0x20)
    4504
                m2 := mload(0x40)
    4505
                m3 := mload(0x60)
    4506
                m4 := mload(0x80)
    4507
                // Selector of `log(address,uint256,uint256,bool)`.
    4508
                mstore(0x00, 0x66f1bc67)
    4509
                mstore(0x20, p0)
    4510
                mstore(0x40, p1)
    4511
                mstore(0x60, p2)
    4512
                mstore(0x80, p3)
    4513
            }
    4514
            _sendLogPayload(0x1c, 0x84);
    4515
            /// @solidity memory-safe-assembly
    4516
            assembly {
    4517
                mstore(0x00, m0)
    4518
                mstore(0x20, m1)
    4519
                mstore(0x40, m2)
    4520
                mstore(0x60, m3)
    4521
                mstore(0x80, m4)
    4522
            }
    4523
        }
    4524
    
                                                    
                                                
    4525
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    4526
            bytes32 m0;
    4527
            bytes32 m1;
    4528
            bytes32 m2;
    4529
            bytes32 m3;
    4530
            bytes32 m4;
    4531
            /// @solidity memory-safe-assembly
    4532
            assembly {
    4533
                m0 := mload(0x00)
    4534
                m1 := mload(0x20)
    4535
                m2 := mload(0x40)
    4536
                m3 := mload(0x60)
    4537
                m4 := mload(0x80)
    4538
                // Selector of `log(address,uint256,uint256,uint256)`.
    4539
                mstore(0x00, 0x34f0e636)
    4540
                mstore(0x20, p0)
    4541
                mstore(0x40, p1)
    4542
                mstore(0x60, p2)
    4543
                mstore(0x80, p3)
    4544
            }
    4545
            _sendLogPayload(0x1c, 0x84);
    4546
            /// @solidity memory-safe-assembly
    4547
            assembly {
    4548
                mstore(0x00, m0)
    4549
                mstore(0x20, m1)
    4550
                mstore(0x40, m2)
    4551
                mstore(0x60, m3)
    4552
                mstore(0x80, m4)
    4553
            }
    4554
        }
    4555
    
                                                    
                                                
    4556
        function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    4557
            bytes32 m0;
    4558
            bytes32 m1;
    4559
            bytes32 m2;
    4560
            bytes32 m3;
    4561
            bytes32 m4;
    4562
            bytes32 m5;
    4563
            bytes32 m6;
    4564
            /// @solidity memory-safe-assembly
    4565
            assembly {
    4566
                function writeString(pos, w) {
    4567
                    let length := 0
    4568
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4569
                    mstore(pos, length)
    4570
                    let shift := sub(256, shl(3, length))
    4571
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4572
                }
    4573
                m0 := mload(0x00)
    4574
                m1 := mload(0x20)
    4575
                m2 := mload(0x40)
    4576
                m3 := mload(0x60)
    4577
                m4 := mload(0x80)
    4578
                m5 := mload(0xa0)
    4579
                m6 := mload(0xc0)
    4580
                // Selector of `log(address,uint256,uint256,string)`.
    4581
                mstore(0x00, 0x4a28c017)
    4582
                mstore(0x20, p0)
    4583
                mstore(0x40, p1)
    4584
                mstore(0x60, p2)
    4585
                mstore(0x80, 0x80)
    4586
                writeString(0xa0, p3)
    4587
            }
    4588
            _sendLogPayload(0x1c, 0xc4);
    4589
            /// @solidity memory-safe-assembly
    4590
            assembly {
    4591
                mstore(0x00, m0)
    4592
                mstore(0x20, m1)
    4593
                mstore(0x40, m2)
    4594
                mstore(0x60, m3)
    4595
                mstore(0x80, m4)
    4596
                mstore(0xa0, m5)
    4597
                mstore(0xc0, m6)
    4598
            }
    4599
        }
    4600
    
                                                    
                                                
    4601
        function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {
    4602
            bytes32 m0;
    4603
            bytes32 m1;
    4604
            bytes32 m2;
    4605
            bytes32 m3;
    4606
            bytes32 m4;
    4607
            bytes32 m5;
    4608
            bytes32 m6;
    4609
            /// @solidity memory-safe-assembly
    4610
            assembly {
    4611
                function writeString(pos, w) {
    4612
                    let length := 0
    4613
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4614
                    mstore(pos, length)
    4615
                    let shift := sub(256, shl(3, length))
    4616
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4617
                }
    4618
                m0 := mload(0x00)
    4619
                m1 := mload(0x20)
    4620
                m2 := mload(0x40)
    4621
                m3 := mload(0x60)
    4622
                m4 := mload(0x80)
    4623
                m5 := mload(0xa0)
    4624
                m6 := mload(0xc0)
    4625
                // Selector of `log(address,uint256,string,address)`.
    4626
                mstore(0x00, 0x5c430d47)
    4627
                mstore(0x20, p0)
    4628
                mstore(0x40, p1)
    4629
                mstore(0x60, 0x80)
    4630
                mstore(0x80, p3)
    4631
                writeString(0xa0, p2)
    4632
            }
    4633
            _sendLogPayload(0x1c, 0xc4);
    4634
            /// @solidity memory-safe-assembly
    4635
            assembly {
    4636
                mstore(0x00, m0)
    4637
                mstore(0x20, m1)
    4638
                mstore(0x40, m2)
    4639
                mstore(0x60, m3)
    4640
                mstore(0x80, m4)
    4641
                mstore(0xa0, m5)
    4642
                mstore(0xc0, m6)
    4643
            }
    4644
        }
    4645
    
                                                    
                                                
    4646
        function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    4647
            bytes32 m0;
    4648
            bytes32 m1;
    4649
            bytes32 m2;
    4650
            bytes32 m3;
    4651
            bytes32 m4;
    4652
            bytes32 m5;
    4653
            bytes32 m6;
    4654
            /// @solidity memory-safe-assembly
    4655
            assembly {
    4656
                function writeString(pos, w) {
    4657
                    let length := 0
    4658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4659
                    mstore(pos, length)
    4660
                    let shift := sub(256, shl(3, length))
    4661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4662
                }
    4663
                m0 := mload(0x00)
    4664
                m1 := mload(0x20)
    4665
                m2 := mload(0x40)
    4666
                m3 := mload(0x60)
    4667
                m4 := mload(0x80)
    4668
                m5 := mload(0xa0)
    4669
                m6 := mload(0xc0)
    4670
                // Selector of `log(address,uint256,string,bool)`.
    4671
                mstore(0x00, 0xcf18105c)
    4672
                mstore(0x20, p0)
    4673
                mstore(0x40, p1)
    4674
                mstore(0x60, 0x80)
    4675
                mstore(0x80, p3)
    4676
                writeString(0xa0, p2)
    4677
            }
    4678
            _sendLogPayload(0x1c, 0xc4);
    4679
            /// @solidity memory-safe-assembly
    4680
            assembly {
    4681
                mstore(0x00, m0)
    4682
                mstore(0x20, m1)
    4683
                mstore(0x40, m2)
    4684
                mstore(0x60, m3)
    4685
                mstore(0x80, m4)
    4686
                mstore(0xa0, m5)
    4687
                mstore(0xc0, m6)
    4688
            }
    4689
        }
    4690
    
                                                    
                                                
    4691
        function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    4692
            bytes32 m0;
    4693
            bytes32 m1;
    4694
            bytes32 m2;
    4695
            bytes32 m3;
    4696
            bytes32 m4;
    4697
            bytes32 m5;
    4698
            bytes32 m6;
    4699
            /// @solidity memory-safe-assembly
    4700
            assembly {
    4701
                function writeString(pos, w) {
    4702
                    let length := 0
    4703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4704
                    mstore(pos, length)
    4705
                    let shift := sub(256, shl(3, length))
    4706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4707
                }
    4708
                m0 := mload(0x00)
    4709
                m1 := mload(0x20)
    4710
                m2 := mload(0x40)
    4711
                m3 := mload(0x60)
    4712
                m4 := mload(0x80)
    4713
                m5 := mload(0xa0)
    4714
                m6 := mload(0xc0)
    4715
                // Selector of `log(address,uint256,string,uint256)`.
    4716
                mstore(0x00, 0xbf01f891)
    4717
                mstore(0x20, p0)
    4718
                mstore(0x40, p1)
    4719
                mstore(0x60, 0x80)
    4720
                mstore(0x80, p3)
    4721
                writeString(0xa0, p2)
    4722
            }
    4723
            _sendLogPayload(0x1c, 0xc4);
    4724
            /// @solidity memory-safe-assembly
    4725
            assembly {
    4726
                mstore(0x00, m0)
    4727
                mstore(0x20, m1)
    4728
                mstore(0x40, m2)
    4729
                mstore(0x60, m3)
    4730
                mstore(0x80, m4)
    4731
                mstore(0xa0, m5)
    4732
                mstore(0xc0, m6)
    4733
            }
    4734
        }
    4735
    
                                                    
                                                
    4736
        function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    4737
            bytes32 m0;
    4738
            bytes32 m1;
    4739
            bytes32 m2;
    4740
            bytes32 m3;
    4741
            bytes32 m4;
    4742
            bytes32 m5;
    4743
            bytes32 m6;
    4744
            bytes32 m7;
    4745
            bytes32 m8;
    4746
            /// @solidity memory-safe-assembly
    4747
            assembly {
    4748
                function writeString(pos, w) {
    4749
                    let length := 0
    4750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4751
                    mstore(pos, length)
    4752
                    let shift := sub(256, shl(3, length))
    4753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4754
                }
    4755
                m0 := mload(0x00)
    4756
                m1 := mload(0x20)
    4757
                m2 := mload(0x40)
    4758
                m3 := mload(0x60)
    4759
                m4 := mload(0x80)
    4760
                m5 := mload(0xa0)
    4761
                m6 := mload(0xc0)
    4762
                m7 := mload(0xe0)
    4763
                m8 := mload(0x100)
    4764
                // Selector of `log(address,uint256,string,string)`.
    4765
                mstore(0x00, 0x88a8c406)
    4766
                mstore(0x20, p0)
    4767
                mstore(0x40, p1)
    4768
                mstore(0x60, 0x80)
    4769
                mstore(0x80, 0xc0)
    4770
                writeString(0xa0, p2)
    4771
                writeString(0xe0, p3)
    4772
            }
    4773
            _sendLogPayload(0x1c, 0x104);
    4774
            /// @solidity memory-safe-assembly
    4775
            assembly {
    4776
                mstore(0x00, m0)
    4777
                mstore(0x20, m1)
    4778
                mstore(0x40, m2)
    4779
                mstore(0x60, m3)
    4780
                mstore(0x80, m4)
    4781
                mstore(0xa0, m5)
    4782
                mstore(0xc0, m6)
    4783
                mstore(0xe0, m7)
    4784
                mstore(0x100, m8)
    4785
            }
    4786
        }
    4787
    
                                                    
                                                
    4788
        function log(address p0, bytes32 p1, address p2, address p3) internal pure {
    4789
            bytes32 m0;
    4790
            bytes32 m1;
    4791
            bytes32 m2;
    4792
            bytes32 m3;
    4793
            bytes32 m4;
    4794
            bytes32 m5;
    4795
            bytes32 m6;
    4796
            /// @solidity memory-safe-assembly
    4797
            assembly {
    4798
                function writeString(pos, w) {
    4799
                    let length := 0
    4800
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4801
                    mstore(pos, length)
    4802
                    let shift := sub(256, shl(3, length))
    4803
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4804
                }
    4805
                m0 := mload(0x00)
    4806
                m1 := mload(0x20)
    4807
                m2 := mload(0x40)
    4808
                m3 := mload(0x60)
    4809
                m4 := mload(0x80)
    4810
                m5 := mload(0xa0)
    4811
                m6 := mload(0xc0)
    4812
                // Selector of `log(address,string,address,address)`.
    4813
                mstore(0x00, 0x0d36fa20)
    4814
                mstore(0x20, p0)
    4815
                mstore(0x40, 0x80)
    4816
                mstore(0x60, p2)
    4817
                mstore(0x80, p3)
    4818
                writeString(0xa0, p1)
    4819
            }
    4820
            _sendLogPayload(0x1c, 0xc4);
    4821
            /// @solidity memory-safe-assembly
    4822
            assembly {
    4823
                mstore(0x00, m0)
    4824
                mstore(0x20, m1)
    4825
                mstore(0x40, m2)
    4826
                mstore(0x60, m3)
    4827
                mstore(0x80, m4)
    4828
                mstore(0xa0, m5)
    4829
                mstore(0xc0, m6)
    4830
            }
    4831
        }
    4832
    
                                                    
                                                
    4833
        function log(address p0, bytes32 p1, address p2, bool p3) internal pure {
    4834
            bytes32 m0;
    4835
            bytes32 m1;
    4836
            bytes32 m2;
    4837
            bytes32 m3;
    4838
            bytes32 m4;
    4839
            bytes32 m5;
    4840
            bytes32 m6;
    4841
            /// @solidity memory-safe-assembly
    4842
            assembly {
    4843
                function writeString(pos, w) {
    4844
                    let length := 0
    4845
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4846
                    mstore(pos, length)
    4847
                    let shift := sub(256, shl(3, length))
    4848
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4849
                }
    4850
                m0 := mload(0x00)
    4851
                m1 := mload(0x20)
    4852
                m2 := mload(0x40)
    4853
                m3 := mload(0x60)
    4854
                m4 := mload(0x80)
    4855
                m5 := mload(0xa0)
    4856
                m6 := mload(0xc0)
    4857
                // Selector of `log(address,string,address,bool)`.
    4858
                mstore(0x00, 0x0df12b76)
    4859
                mstore(0x20, p0)
    4860
                mstore(0x40, 0x80)
    4861
                mstore(0x60, p2)
    4862
                mstore(0x80, p3)
    4863
                writeString(0xa0, p1)
    4864
            }
    4865
            _sendLogPayload(0x1c, 0xc4);
    4866
            /// @solidity memory-safe-assembly
    4867
            assembly {
    4868
                mstore(0x00, m0)
    4869
                mstore(0x20, m1)
    4870
                mstore(0x40, m2)
    4871
                mstore(0x60, m3)
    4872
                mstore(0x80, m4)
    4873
                mstore(0xa0, m5)
    4874
                mstore(0xc0, m6)
    4875
            }
    4876
        }
    4877
    
                                                    
                                                
    4878
        function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {
    4879
            bytes32 m0;
    4880
            bytes32 m1;
    4881
            bytes32 m2;
    4882
            bytes32 m3;
    4883
            bytes32 m4;
    4884
            bytes32 m5;
    4885
            bytes32 m6;
    4886
            /// @solidity memory-safe-assembly
    4887
            assembly {
    4888
                function writeString(pos, w) {
    4889
                    let length := 0
    4890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4891
                    mstore(pos, length)
    4892
                    let shift := sub(256, shl(3, length))
    4893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4894
                }
    4895
                m0 := mload(0x00)
    4896
                m1 := mload(0x20)
    4897
                m2 := mload(0x40)
    4898
                m3 := mload(0x60)
    4899
                m4 := mload(0x80)
    4900
                m5 := mload(0xa0)
    4901
                m6 := mload(0xc0)
    4902
                // Selector of `log(address,string,address,uint256)`.
    4903
                mstore(0x00, 0x457fe3cf)
    4904
                mstore(0x20, p0)
    4905
                mstore(0x40, 0x80)
    4906
                mstore(0x60, p2)
    4907
                mstore(0x80, p3)
    4908
                writeString(0xa0, p1)
    4909
            }
    4910
            _sendLogPayload(0x1c, 0xc4);
    4911
            /// @solidity memory-safe-assembly
    4912
            assembly {
    4913
                mstore(0x00, m0)
    4914
                mstore(0x20, m1)
    4915
                mstore(0x40, m2)
    4916
                mstore(0x60, m3)
    4917
                mstore(0x80, m4)
    4918
                mstore(0xa0, m5)
    4919
                mstore(0xc0, m6)
    4920
            }
    4921
        }
    4922
    
                                                    
                                                
    4923
        function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    4924
            bytes32 m0;
    4925
            bytes32 m1;
    4926
            bytes32 m2;
    4927
            bytes32 m3;
    4928
            bytes32 m4;
    4929
            bytes32 m5;
    4930
            bytes32 m6;
    4931
            bytes32 m7;
    4932
            bytes32 m8;
    4933
            /// @solidity memory-safe-assembly
    4934
            assembly {
    4935
                function writeString(pos, w) {
    4936
                    let length := 0
    4937
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4938
                    mstore(pos, length)
    4939
                    let shift := sub(256, shl(3, length))
    4940
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4941
                }
    4942
                m0 := mload(0x00)
    4943
                m1 := mload(0x20)
    4944
                m2 := mload(0x40)
    4945
                m3 := mload(0x60)
    4946
                m4 := mload(0x80)
    4947
                m5 := mload(0xa0)
    4948
                m6 := mload(0xc0)
    4949
                m7 := mload(0xe0)
    4950
                m8 := mload(0x100)
    4951
                // Selector of `log(address,string,address,string)`.
    4952
                mstore(0x00, 0xf7e36245)
    4953
                mstore(0x20, p0)
    4954
                mstore(0x40, 0x80)
    4955
                mstore(0x60, p2)
    4956
                mstore(0x80, 0xc0)
    4957
                writeString(0xa0, p1)
    4958
                writeString(0xe0, p3)
    4959
            }
    4960
            _sendLogPayload(0x1c, 0x104);
    4961
            /// @solidity memory-safe-assembly
    4962
            assembly {
    4963
                mstore(0x00, m0)
    4964
                mstore(0x20, m1)
    4965
                mstore(0x40, m2)
    4966
                mstore(0x60, m3)
    4967
                mstore(0x80, m4)
    4968
                mstore(0xa0, m5)
    4969
                mstore(0xc0, m6)
    4970
                mstore(0xe0, m7)
    4971
                mstore(0x100, m8)
    4972
            }
    4973
        }
    4974
    
                                                    
                                                
    4975
        function log(address p0, bytes32 p1, bool p2, address p3) internal pure {
    4976
            bytes32 m0;
    4977
            bytes32 m1;
    4978
            bytes32 m2;
    4979
            bytes32 m3;
    4980
            bytes32 m4;
    4981
            bytes32 m5;
    4982
            bytes32 m6;
    4983
            /// @solidity memory-safe-assembly
    4984
            assembly {
    4985
                function writeString(pos, w) {
    4986
                    let length := 0
    4987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4988
                    mstore(pos, length)
    4989
                    let shift := sub(256, shl(3, length))
    4990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4991
                }
    4992
                m0 := mload(0x00)
    4993
                m1 := mload(0x20)
    4994
                m2 := mload(0x40)
    4995
                m3 := mload(0x60)
    4996
                m4 := mload(0x80)
    4997
                m5 := mload(0xa0)
    4998
                m6 := mload(0xc0)
    4999
                // Selector of `log(address,string,bool,address)`.
    5000
                mstore(0x00, 0x205871c2)
    5001
                mstore(0x20, p0)
    5002
                mstore(0x40, 0x80)
    5003
                mstore(0x60, p2)
    5004
                mstore(0x80, p3)
    5005
                writeString(0xa0, p1)
    5006
            }
    5007
            _sendLogPayload(0x1c, 0xc4);
    5008
            /// @solidity memory-safe-assembly
    5009
            assembly {
    5010
                mstore(0x00, m0)
    5011
                mstore(0x20, m1)
    5012
                mstore(0x40, m2)
    5013
                mstore(0x60, m3)
    5014
                mstore(0x80, m4)
    5015
                mstore(0xa0, m5)
    5016
                mstore(0xc0, m6)
    5017
            }
    5018
        }
    5019
    
                                                    
                                                
    5020
        function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {
    5021
            bytes32 m0;
    5022
            bytes32 m1;
    5023
            bytes32 m2;
    5024
            bytes32 m3;
    5025
            bytes32 m4;
    5026
            bytes32 m5;
    5027
            bytes32 m6;
    5028
            /// @solidity memory-safe-assembly
    5029
            assembly {
    5030
                function writeString(pos, w) {
    5031
                    let length := 0
    5032
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5033
                    mstore(pos, length)
    5034
                    let shift := sub(256, shl(3, length))
    5035
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5036
                }
    5037
                m0 := mload(0x00)
    5038
                m1 := mload(0x20)
    5039
                m2 := mload(0x40)
    5040
                m3 := mload(0x60)
    5041
                m4 := mload(0x80)
    5042
                m5 := mload(0xa0)
    5043
                m6 := mload(0xc0)
    5044
                // Selector of `log(address,string,bool,bool)`.
    5045
                mstore(0x00, 0x5f1d5c9f)
    5046
                mstore(0x20, p0)
    5047
                mstore(0x40, 0x80)
    5048
                mstore(0x60, p2)
    5049
                mstore(0x80, p3)
    5050
                writeString(0xa0, p1)
    5051
            }
    5052
            _sendLogPayload(0x1c, 0xc4);
    5053
            /// @solidity memory-safe-assembly
    5054
            assembly {
    5055
                mstore(0x00, m0)
    5056
                mstore(0x20, m1)
    5057
                mstore(0x40, m2)
    5058
                mstore(0x60, m3)
    5059
                mstore(0x80, m4)
    5060
                mstore(0xa0, m5)
    5061
                mstore(0xc0, m6)
    5062
            }
    5063
        }
    5064
    
                                                    
                                                
    5065
        function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    5066
            bytes32 m0;
    5067
            bytes32 m1;
    5068
            bytes32 m2;
    5069
            bytes32 m3;
    5070
            bytes32 m4;
    5071
            bytes32 m5;
    5072
            bytes32 m6;
    5073
            /// @solidity memory-safe-assembly
    5074
            assembly {
    5075
                function writeString(pos, w) {
    5076
                    let length := 0
    5077
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5078
                    mstore(pos, length)
    5079
                    let shift := sub(256, shl(3, length))
    5080
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5081
                }
    5082
                m0 := mload(0x00)
    5083
                m1 := mload(0x20)
    5084
                m2 := mload(0x40)
    5085
                m3 := mload(0x60)
    5086
                m4 := mload(0x80)
    5087
                m5 := mload(0xa0)
    5088
                m6 := mload(0xc0)
    5089
                // Selector of `log(address,string,bool,uint256)`.
    5090
                mstore(0x00, 0x515e38b6)
    5091
                mstore(0x20, p0)
    5092
                mstore(0x40, 0x80)
    5093
                mstore(0x60, p2)
    5094
                mstore(0x80, p3)
    5095
                writeString(0xa0, p1)
    5096
            }
    5097
            _sendLogPayload(0x1c, 0xc4);
    5098
            /// @solidity memory-safe-assembly
    5099
            assembly {
    5100
                mstore(0x00, m0)
    5101
                mstore(0x20, m1)
    5102
                mstore(0x40, m2)
    5103
                mstore(0x60, m3)
    5104
                mstore(0x80, m4)
    5105
                mstore(0xa0, m5)
    5106
                mstore(0xc0, m6)
    5107
            }
    5108
        }
    5109
    
                                                    
                                                
    5110
        function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    5111
            bytes32 m0;
    5112
            bytes32 m1;
    5113
            bytes32 m2;
    5114
            bytes32 m3;
    5115
            bytes32 m4;
    5116
            bytes32 m5;
    5117
            bytes32 m6;
    5118
            bytes32 m7;
    5119
            bytes32 m8;
    5120
            /// @solidity memory-safe-assembly
    5121
            assembly {
    5122
                function writeString(pos, w) {
    5123
                    let length := 0
    5124
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5125
                    mstore(pos, length)
    5126
                    let shift := sub(256, shl(3, length))
    5127
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5128
                }
    5129
                m0 := mload(0x00)
    5130
                m1 := mload(0x20)
    5131
                m2 := mload(0x40)
    5132
                m3 := mload(0x60)
    5133
                m4 := mload(0x80)
    5134
                m5 := mload(0xa0)
    5135
                m6 := mload(0xc0)
    5136
                m7 := mload(0xe0)
    5137
                m8 := mload(0x100)
    5138
                // Selector of `log(address,string,bool,string)`.
    5139
                mstore(0x00, 0xbc0b61fe)
    5140
                mstore(0x20, p0)
    5141
                mstore(0x40, 0x80)
    5142
                mstore(0x60, p2)
    5143
                mstore(0x80, 0xc0)
    5144
                writeString(0xa0, p1)
    5145
                writeString(0xe0, p3)
    5146
            }
    5147
            _sendLogPayload(0x1c, 0x104);
    5148
            /// @solidity memory-safe-assembly
    5149
            assembly {
    5150
                mstore(0x00, m0)
    5151
                mstore(0x20, m1)
    5152
                mstore(0x40, m2)
    5153
                mstore(0x60, m3)
    5154
                mstore(0x80, m4)
    5155
                mstore(0xa0, m5)
    5156
                mstore(0xc0, m6)
    5157
                mstore(0xe0, m7)
    5158
                mstore(0x100, m8)
    5159
            }
    5160
        }
    5161
    
                                                    
                                                
    5162
        function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {
    5163
            bytes32 m0;
    5164
            bytes32 m1;
    5165
            bytes32 m2;
    5166
            bytes32 m3;
    5167
            bytes32 m4;
    5168
            bytes32 m5;
    5169
            bytes32 m6;
    5170
            /// @solidity memory-safe-assembly
    5171
            assembly {
    5172
                function writeString(pos, w) {
    5173
                    let length := 0
    5174
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5175
                    mstore(pos, length)
    5176
                    let shift := sub(256, shl(3, length))
    5177
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5178
                }
    5179
                m0 := mload(0x00)
    5180
                m1 := mload(0x20)
    5181
                m2 := mload(0x40)
    5182
                m3 := mload(0x60)
    5183
                m4 := mload(0x80)
    5184
                m5 := mload(0xa0)
    5185
                m6 := mload(0xc0)
    5186
                // Selector of `log(address,string,uint256,address)`.
    5187
                mstore(0x00, 0x63183678)
    5188
                mstore(0x20, p0)
    5189
                mstore(0x40, 0x80)
    5190
                mstore(0x60, p2)
    5191
                mstore(0x80, p3)
    5192
                writeString(0xa0, p1)
    5193
            }
    5194
            _sendLogPayload(0x1c, 0xc4);
    5195
            /// @solidity memory-safe-assembly
    5196
            assembly {
    5197
                mstore(0x00, m0)
    5198
                mstore(0x20, m1)
    5199
                mstore(0x40, m2)
    5200
                mstore(0x60, m3)
    5201
                mstore(0x80, m4)
    5202
                mstore(0xa0, m5)
    5203
                mstore(0xc0, m6)
    5204
            }
    5205
        }
    5206
    
                                                    
                                                
    5207
        function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    5208
            bytes32 m0;
    5209
            bytes32 m1;
    5210
            bytes32 m2;
    5211
            bytes32 m3;
    5212
            bytes32 m4;
    5213
            bytes32 m5;
    5214
            bytes32 m6;
    5215
            /// @solidity memory-safe-assembly
    5216
            assembly {
    5217
                function writeString(pos, w) {
    5218
                    let length := 0
    5219
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5220
                    mstore(pos, length)
    5221
                    let shift := sub(256, shl(3, length))
    5222
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5223
                }
    5224
                m0 := mload(0x00)
    5225
                m1 := mload(0x20)
    5226
                m2 := mload(0x40)
    5227
                m3 := mload(0x60)
    5228
                m4 := mload(0x80)
    5229
                m5 := mload(0xa0)
    5230
                m6 := mload(0xc0)
    5231
                // Selector of `log(address,string,uint256,bool)`.
    5232
                mstore(0x00, 0x0ef7e050)
    5233
                mstore(0x20, p0)
    5234
                mstore(0x40, 0x80)
    5235
                mstore(0x60, p2)
    5236
                mstore(0x80, p3)
    5237
                writeString(0xa0, p1)
    5238
            }
    5239
            _sendLogPayload(0x1c, 0xc4);
    5240
            /// @solidity memory-safe-assembly
    5241
            assembly {
    5242
                mstore(0x00, m0)
    5243
                mstore(0x20, m1)
    5244
                mstore(0x40, m2)
    5245
                mstore(0x60, m3)
    5246
                mstore(0x80, m4)
    5247
                mstore(0xa0, m5)
    5248
                mstore(0xc0, m6)
    5249
            }
    5250
        }
    5251
    
                                                    
                                                
    5252
        function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    5253
            bytes32 m0;
    5254
            bytes32 m1;
    5255
            bytes32 m2;
    5256
            bytes32 m3;
    5257
            bytes32 m4;
    5258
            bytes32 m5;
    5259
            bytes32 m6;
    5260
            /// @solidity memory-safe-assembly
    5261
            assembly {
    5262
                function writeString(pos, w) {
    5263
                    let length := 0
    5264
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5265
                    mstore(pos, length)
    5266
                    let shift := sub(256, shl(3, length))
    5267
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5268
                }
    5269
                m0 := mload(0x00)
    5270
                m1 := mload(0x20)
    5271
                m2 := mload(0x40)
    5272
                m3 := mload(0x60)
    5273
                m4 := mload(0x80)
    5274
                m5 := mload(0xa0)
    5275
                m6 := mload(0xc0)
    5276
                // Selector of `log(address,string,uint256,uint256)`.
    5277
                mstore(0x00, 0x1dc8e1b8)
    5278
                mstore(0x20, p0)
    5279
                mstore(0x40, 0x80)
    5280
                mstore(0x60, p2)
    5281
                mstore(0x80, p3)
    5282
                writeString(0xa0, p1)
    5283
            }
    5284
            _sendLogPayload(0x1c, 0xc4);
    5285
            /// @solidity memory-safe-assembly
    5286
            assembly {
    5287
                mstore(0x00, m0)
    5288
                mstore(0x20, m1)
    5289
                mstore(0x40, m2)
    5290
                mstore(0x60, m3)
    5291
                mstore(0x80, m4)
    5292
                mstore(0xa0, m5)
    5293
                mstore(0xc0, m6)
    5294
            }
    5295
        }
    5296
    
                                                    
                                                
    5297
        function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    5298
            bytes32 m0;
    5299
            bytes32 m1;
    5300
            bytes32 m2;
    5301
            bytes32 m3;
    5302
            bytes32 m4;
    5303
            bytes32 m5;
    5304
            bytes32 m6;
    5305
            bytes32 m7;
    5306
            bytes32 m8;
    5307
            /// @solidity memory-safe-assembly
    5308
            assembly {
    5309
                function writeString(pos, w) {
    5310
                    let length := 0
    5311
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5312
                    mstore(pos, length)
    5313
                    let shift := sub(256, shl(3, length))
    5314
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5315
                }
    5316
                m0 := mload(0x00)
    5317
                m1 := mload(0x20)
    5318
                m2 := mload(0x40)
    5319
                m3 := mload(0x60)
    5320
                m4 := mload(0x80)
    5321
                m5 := mload(0xa0)
    5322
                m6 := mload(0xc0)
    5323
                m7 := mload(0xe0)
    5324
                m8 := mload(0x100)
    5325
                // Selector of `log(address,string,uint256,string)`.
    5326
                mstore(0x00, 0x448830a8)
    5327
                mstore(0x20, p0)
    5328
                mstore(0x40, 0x80)
    5329
                mstore(0x60, p2)
    5330
                mstore(0x80, 0xc0)
    5331
                writeString(0xa0, p1)
    5332
                writeString(0xe0, p3)
    5333
            }
    5334
            _sendLogPayload(0x1c, 0x104);
    5335
            /// @solidity memory-safe-assembly
    5336
            assembly {
    5337
                mstore(0x00, m0)
    5338
                mstore(0x20, m1)
    5339
                mstore(0x40, m2)
    5340
                mstore(0x60, m3)
    5341
                mstore(0x80, m4)
    5342
                mstore(0xa0, m5)
    5343
                mstore(0xc0, m6)
    5344
                mstore(0xe0, m7)
    5345
                mstore(0x100, m8)
    5346
            }
    5347
        }
    5348
    
                                                    
                                                
    5349
        function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    5350
            bytes32 m0;
    5351
            bytes32 m1;
    5352
            bytes32 m2;
    5353
            bytes32 m3;
    5354
            bytes32 m4;
    5355
            bytes32 m5;
    5356
            bytes32 m6;
    5357
            bytes32 m7;
    5358
            bytes32 m8;
    5359
            /// @solidity memory-safe-assembly
    5360
            assembly {
    5361
                function writeString(pos, w) {
    5362
                    let length := 0
    5363
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5364
                    mstore(pos, length)
    5365
                    let shift := sub(256, shl(3, length))
    5366
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5367
                }
    5368
                m0 := mload(0x00)
    5369
                m1 := mload(0x20)
    5370
                m2 := mload(0x40)
    5371
                m3 := mload(0x60)
    5372
                m4 := mload(0x80)
    5373
                m5 := mload(0xa0)
    5374
                m6 := mload(0xc0)
    5375
                m7 := mload(0xe0)
    5376
                m8 := mload(0x100)
    5377
                // Selector of `log(address,string,string,address)`.
    5378
                mstore(0x00, 0xa04e2f87)
    5379
                mstore(0x20, p0)
    5380
                mstore(0x40, 0x80)
    5381
                mstore(0x60, 0xc0)
    5382
                mstore(0x80, p3)
    5383
                writeString(0xa0, p1)
    5384
                writeString(0xe0, p2)
    5385
            }
    5386
            _sendLogPayload(0x1c, 0x104);
    5387
            /// @solidity memory-safe-assembly
    5388
            assembly {
    5389
                mstore(0x00, m0)
    5390
                mstore(0x20, m1)
    5391
                mstore(0x40, m2)
    5392
                mstore(0x60, m3)
    5393
                mstore(0x80, m4)
    5394
                mstore(0xa0, m5)
    5395
                mstore(0xc0, m6)
    5396
                mstore(0xe0, m7)
    5397
                mstore(0x100, m8)
    5398
            }
    5399
        }
    5400
    
                                                    
                                                
    5401
        function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    5402
            bytes32 m0;
    5403
            bytes32 m1;
    5404
            bytes32 m2;
    5405
            bytes32 m3;
    5406
            bytes32 m4;
    5407
            bytes32 m5;
    5408
            bytes32 m6;
    5409
            bytes32 m7;
    5410
            bytes32 m8;
    5411
            /// @solidity memory-safe-assembly
    5412
            assembly {
    5413
                function writeString(pos, w) {
    5414
                    let length := 0
    5415
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5416
                    mstore(pos, length)
    5417
                    let shift := sub(256, shl(3, length))
    5418
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5419
                }
    5420
                m0 := mload(0x00)
    5421
                m1 := mload(0x20)
    5422
                m2 := mload(0x40)
    5423
                m3 := mload(0x60)
    5424
                m4 := mload(0x80)
    5425
                m5 := mload(0xa0)
    5426
                m6 := mload(0xc0)
    5427
                m7 := mload(0xe0)
    5428
                m8 := mload(0x100)
    5429
                // Selector of `log(address,string,string,bool)`.
    5430
                mstore(0x00, 0x35a5071f)
    5431
                mstore(0x20, p0)
    5432
                mstore(0x40, 0x80)
    5433
                mstore(0x60, 0xc0)
    5434
                mstore(0x80, p3)
    5435
                writeString(0xa0, p1)
    5436
                writeString(0xe0, p2)
    5437
            }
    5438
            _sendLogPayload(0x1c, 0x104);
    5439
            /// @solidity memory-safe-assembly
    5440
            assembly {
    5441
                mstore(0x00, m0)
    5442
                mstore(0x20, m1)
    5443
                mstore(0x40, m2)
    5444
                mstore(0x60, m3)
    5445
                mstore(0x80, m4)
    5446
                mstore(0xa0, m5)
    5447
                mstore(0xc0, m6)
    5448
                mstore(0xe0, m7)
    5449
                mstore(0x100, m8)
    5450
            }
    5451
        }
    5452
    
                                                    
                                                
    5453
        function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    5454
            bytes32 m0;
    5455
            bytes32 m1;
    5456
            bytes32 m2;
    5457
            bytes32 m3;
    5458
            bytes32 m4;
    5459
            bytes32 m5;
    5460
            bytes32 m6;
    5461
            bytes32 m7;
    5462
            bytes32 m8;
    5463
            /// @solidity memory-safe-assembly
    5464
            assembly {
    5465
                function writeString(pos, w) {
    5466
                    let length := 0
    5467
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5468
                    mstore(pos, length)
    5469
                    let shift := sub(256, shl(3, length))
    5470
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5471
                }
    5472
                m0 := mload(0x00)
    5473
                m1 := mload(0x20)
    5474
                m2 := mload(0x40)
    5475
                m3 := mload(0x60)
    5476
                m4 := mload(0x80)
    5477
                m5 := mload(0xa0)
    5478
                m6 := mload(0xc0)
    5479
                m7 := mload(0xe0)
    5480
                m8 := mload(0x100)
    5481
                // Selector of `log(address,string,string,uint256)`.
    5482
                mstore(0x00, 0x159f8927)
    5483
                mstore(0x20, p0)
    5484
                mstore(0x40, 0x80)
    5485
                mstore(0x60, 0xc0)
    5486
                mstore(0x80, p3)
    5487
                writeString(0xa0, p1)
    5488
                writeString(0xe0, p2)
    5489
            }
    5490
            _sendLogPayload(0x1c, 0x104);
    5491
            /// @solidity memory-safe-assembly
    5492
            assembly {
    5493
                mstore(0x00, m0)
    5494
                mstore(0x20, m1)
    5495
                mstore(0x40, m2)
    5496
                mstore(0x60, m3)
    5497
                mstore(0x80, m4)
    5498
                mstore(0xa0, m5)
    5499
                mstore(0xc0, m6)
    5500
                mstore(0xe0, m7)
    5501
                mstore(0x100, m8)
    5502
            }
    5503
        }
    5504
    
                                                    
                                                
    5505
        function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    5506
            bytes32 m0;
    5507
            bytes32 m1;
    5508
            bytes32 m2;
    5509
            bytes32 m3;
    5510
            bytes32 m4;
    5511
            bytes32 m5;
    5512
            bytes32 m6;
    5513
            bytes32 m7;
    5514
            bytes32 m8;
    5515
            bytes32 m9;
    5516
            bytes32 m10;
    5517
            /// @solidity memory-safe-assembly
    5518
            assembly {
    5519
                function writeString(pos, w) {
    5520
                    let length := 0
    5521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5522
                    mstore(pos, length)
    5523
                    let shift := sub(256, shl(3, length))
    5524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5525
                }
    5526
                m0 := mload(0x00)
    5527
                m1 := mload(0x20)
    5528
                m2 := mload(0x40)
    5529
                m3 := mload(0x60)
    5530
                m4 := mload(0x80)
    5531
                m5 := mload(0xa0)
    5532
                m6 := mload(0xc0)
    5533
                m7 := mload(0xe0)
    5534
                m8 := mload(0x100)
    5535
                m9 := mload(0x120)
    5536
                m10 := mload(0x140)
    5537
                // Selector of `log(address,string,string,string)`.
    5538
                mstore(0x00, 0x5d02c50b)
    5539
                mstore(0x20, p0)
    5540
                mstore(0x40, 0x80)
    5541
                mstore(0x60, 0xc0)
    5542
                mstore(0x80, 0x100)
    5543
                writeString(0xa0, p1)
    5544
                writeString(0xe0, p2)
    5545
                writeString(0x120, p3)
    5546
            }
    5547
            _sendLogPayload(0x1c, 0x144);
    5548
            /// @solidity memory-safe-assembly
    5549
            assembly {
    5550
                mstore(0x00, m0)
    5551
                mstore(0x20, m1)
    5552
                mstore(0x40, m2)
    5553
                mstore(0x60, m3)
    5554
                mstore(0x80, m4)
    5555
                mstore(0xa0, m5)
    5556
                mstore(0xc0, m6)
    5557
                mstore(0xe0, m7)
    5558
                mstore(0x100, m8)
    5559
                mstore(0x120, m9)
    5560
                mstore(0x140, m10)
    5561
            }
    5562
        }
    5563
    
                                                    
                                                
    5564
        function log(bool p0, address p1, address p2, address p3) internal pure {
    5565
            bytes32 m0;
    5566
            bytes32 m1;
    5567
            bytes32 m2;
    5568
            bytes32 m3;
    5569
            bytes32 m4;
    5570
            /// @solidity memory-safe-assembly
    5571
            assembly {
    5572
                m0 := mload(0x00)
    5573
                m1 := mload(0x20)
    5574
                m2 := mload(0x40)
    5575
                m3 := mload(0x60)
    5576
                m4 := mload(0x80)
    5577
                // Selector of `log(bool,address,address,address)`.
    5578
                mstore(0x00, 0x1d14d001)
    5579
                mstore(0x20, p0)
    5580
                mstore(0x40, p1)
    5581
                mstore(0x60, p2)
    5582
                mstore(0x80, p3)
    5583
            }
    5584
            _sendLogPayload(0x1c, 0x84);
    5585
            /// @solidity memory-safe-assembly
    5586
            assembly {
    5587
                mstore(0x00, m0)
    5588
                mstore(0x20, m1)
    5589
                mstore(0x40, m2)
    5590
                mstore(0x60, m3)
    5591
                mstore(0x80, m4)
    5592
            }
    5593
        }
    5594
    
                                                    
                                                
    5595
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    5596
            bytes32 m0;
    5597
            bytes32 m1;
    5598
            bytes32 m2;
    5599
            bytes32 m3;
    5600
            bytes32 m4;
    5601
            /// @solidity memory-safe-assembly
    5602
            assembly {
    5603
                m0 := mload(0x00)
    5604
                m1 := mload(0x20)
    5605
                m2 := mload(0x40)
    5606
                m3 := mload(0x60)
    5607
                m4 := mload(0x80)
    5608
                // Selector of `log(bool,address,address,bool)`.
    5609
                mstore(0x00, 0x46600be0)
    5610
                mstore(0x20, p0)
    5611
                mstore(0x40, p1)
    5612
                mstore(0x60, p2)
    5613
                mstore(0x80, p3)
    5614
            }
    5615
            _sendLogPayload(0x1c, 0x84);
    5616
            /// @solidity memory-safe-assembly
    5617
            assembly {
    5618
                mstore(0x00, m0)
    5619
                mstore(0x20, m1)
    5620
                mstore(0x40, m2)
    5621
                mstore(0x60, m3)
    5622
                mstore(0x80, m4)
    5623
            }
    5624
        }
    5625
    
                                                    
                                                
    5626
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    5627
            bytes32 m0;
    5628
            bytes32 m1;
    5629
            bytes32 m2;
    5630
            bytes32 m3;
    5631
            bytes32 m4;
    5632
            /// @solidity memory-safe-assembly
    5633
            assembly {
    5634
                m0 := mload(0x00)
    5635
                m1 := mload(0x20)
    5636
                m2 := mload(0x40)
    5637
                m3 := mload(0x60)
    5638
                m4 := mload(0x80)
    5639
                // Selector of `log(bool,address,address,uint256)`.
    5640
                mstore(0x00, 0x0c66d1be)
    5641
                mstore(0x20, p0)
    5642
                mstore(0x40, p1)
    5643
                mstore(0x60, p2)
    5644
                mstore(0x80, p3)
    5645
            }
    5646
            _sendLogPayload(0x1c, 0x84);
    5647
            /// @solidity memory-safe-assembly
    5648
            assembly {
    5649
                mstore(0x00, m0)
    5650
                mstore(0x20, m1)
    5651
                mstore(0x40, m2)
    5652
                mstore(0x60, m3)
    5653
                mstore(0x80, m4)
    5654
            }
    5655
        }
    5656
    
                                                    
                                                
    5657
        function log(bool p0, address p1, address p2, bytes32 p3) internal pure {
    5658
            bytes32 m0;
    5659
            bytes32 m1;
    5660
            bytes32 m2;
    5661
            bytes32 m3;
    5662
            bytes32 m4;
    5663
            bytes32 m5;
    5664
            bytes32 m6;
    5665
            /// @solidity memory-safe-assembly
    5666
            assembly {
    5667
                function writeString(pos, w) {
    5668
                    let length := 0
    5669
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5670
                    mstore(pos, length)
    5671
                    let shift := sub(256, shl(3, length))
    5672
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5673
                }
    5674
                m0 := mload(0x00)
    5675
                m1 := mload(0x20)
    5676
                m2 := mload(0x40)
    5677
                m3 := mload(0x60)
    5678
                m4 := mload(0x80)
    5679
                m5 := mload(0xa0)
    5680
                m6 := mload(0xc0)
    5681
                // Selector of `log(bool,address,address,string)`.
    5682
                mstore(0x00, 0xd812a167)
    5683
                mstore(0x20, p0)
    5684
                mstore(0x40, p1)
    5685
                mstore(0x60, p2)
    5686
                mstore(0x80, 0x80)
    5687
                writeString(0xa0, p3)
    5688
            }
    5689
            _sendLogPayload(0x1c, 0xc4);
    5690
            /// @solidity memory-safe-assembly
    5691
            assembly {
    5692
                mstore(0x00, m0)
    5693
                mstore(0x20, m1)
    5694
                mstore(0x40, m2)
    5695
                mstore(0x60, m3)
    5696
                mstore(0x80, m4)
    5697
                mstore(0xa0, m5)
    5698
                mstore(0xc0, m6)
    5699
            }
    5700
        }
    5701
    
                                                    
                                                
    5702
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    5703
            bytes32 m0;
    5704
            bytes32 m1;
    5705
            bytes32 m2;
    5706
            bytes32 m3;
    5707
            bytes32 m4;
    5708
            /// @solidity memory-safe-assembly
    5709
            assembly {
    5710
                m0 := mload(0x00)
    5711
                m1 := mload(0x20)
    5712
                m2 := mload(0x40)
    5713
                m3 := mload(0x60)
    5714
                m4 := mload(0x80)
    5715
                // Selector of `log(bool,address,bool,address)`.
    5716
                mstore(0x00, 0x1c41a336)
    5717
                mstore(0x20, p0)
    5718
                mstore(0x40, p1)
    5719
                mstore(0x60, p2)
    5720
                mstore(0x80, p3)
    5721
            }
    5722
            _sendLogPayload(0x1c, 0x84);
    5723
            /// @solidity memory-safe-assembly
    5724
            assembly {
    5725
                mstore(0x00, m0)
    5726
                mstore(0x20, m1)
    5727
                mstore(0x40, m2)
    5728
                mstore(0x60, m3)
    5729
                mstore(0x80, m4)
    5730
            }
    5731
        }
    5732
    
                                                    
                                                
    5733
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    5734
            bytes32 m0;
    5735
            bytes32 m1;
    5736
            bytes32 m2;
    5737
            bytes32 m3;
    5738
            bytes32 m4;
    5739
            /// @solidity memory-safe-assembly
    5740
            assembly {
    5741
                m0 := mload(0x00)
    5742
                m1 := mload(0x20)
    5743
                m2 := mload(0x40)
    5744
                m3 := mload(0x60)
    5745
                m4 := mload(0x80)
    5746
                // Selector of `log(bool,address,bool,bool)`.
    5747
                mstore(0x00, 0x6a9c478b)
    5748
                mstore(0x20, p0)
    5749
                mstore(0x40, p1)
    5750
                mstore(0x60, p2)
    5751
                mstore(0x80, p3)
    5752
            }
    5753
            _sendLogPayload(0x1c, 0x84);
    5754
            /// @solidity memory-safe-assembly
    5755
            assembly {
    5756
                mstore(0x00, m0)
    5757
                mstore(0x20, m1)
    5758
                mstore(0x40, m2)
    5759
                mstore(0x60, m3)
    5760
                mstore(0x80, m4)
    5761
            }
    5762
        }
    5763
    
                                                    
                                                
    5764
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    5765
            bytes32 m0;
    5766
            bytes32 m1;
    5767
            bytes32 m2;
    5768
            bytes32 m3;
    5769
            bytes32 m4;
    5770
            /// @solidity memory-safe-assembly
    5771
            assembly {
    5772
                m0 := mload(0x00)
    5773
                m1 := mload(0x20)
    5774
                m2 := mload(0x40)
    5775
                m3 := mload(0x60)
    5776
                m4 := mload(0x80)
    5777
                // Selector of `log(bool,address,bool,uint256)`.
    5778
                mstore(0x00, 0x07831502)
    5779
                mstore(0x20, p0)
    5780
                mstore(0x40, p1)
    5781
                mstore(0x60, p2)
    5782
                mstore(0x80, p3)
    5783
            }
    5784
            _sendLogPayload(0x1c, 0x84);
    5785
            /// @solidity memory-safe-assembly
    5786
            assembly {
    5787
                mstore(0x00, m0)
    5788
                mstore(0x20, m1)
    5789
                mstore(0x40, m2)
    5790
                mstore(0x60, m3)
    5791
                mstore(0x80, m4)
    5792
            }
    5793
        }
    5794
    
                                                    
                                                
    5795
        function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {
    5796
            bytes32 m0;
    5797
            bytes32 m1;
    5798
            bytes32 m2;
    5799
            bytes32 m3;
    5800
            bytes32 m4;
    5801
            bytes32 m5;
    5802
            bytes32 m6;
    5803
            /// @solidity memory-safe-assembly
    5804
            assembly {
    5805
                function writeString(pos, w) {
    5806
                    let length := 0
    5807
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5808
                    mstore(pos, length)
    5809
                    let shift := sub(256, shl(3, length))
    5810
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5811
                }
    5812
                m0 := mload(0x00)
    5813
                m1 := mload(0x20)
    5814
                m2 := mload(0x40)
    5815
                m3 := mload(0x60)
    5816
                m4 := mload(0x80)
    5817
                m5 := mload(0xa0)
    5818
                m6 := mload(0xc0)
    5819
                // Selector of `log(bool,address,bool,string)`.
    5820
                mstore(0x00, 0x4a66cb34)
    5821
                mstore(0x20, p0)
    5822
                mstore(0x40, p1)
    5823
                mstore(0x60, p2)
    5824
                mstore(0x80, 0x80)
    5825
                writeString(0xa0, p3)
    5826
            }
    5827
            _sendLogPayload(0x1c, 0xc4);
    5828
            /// @solidity memory-safe-assembly
    5829
            assembly {
    5830
                mstore(0x00, m0)
    5831
                mstore(0x20, m1)
    5832
                mstore(0x40, m2)
    5833
                mstore(0x60, m3)
    5834
                mstore(0x80, m4)
    5835
                mstore(0xa0, m5)
    5836
                mstore(0xc0, m6)
    5837
            }
    5838
        }
    5839
    
                                                    
                                                
    5840
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    5841
            bytes32 m0;
    5842
            bytes32 m1;
    5843
            bytes32 m2;
    5844
            bytes32 m3;
    5845
            bytes32 m4;
    5846
            /// @solidity memory-safe-assembly
    5847
            assembly {
    5848
                m0 := mload(0x00)
    5849
                m1 := mload(0x20)
    5850
                m2 := mload(0x40)
    5851
                m3 := mload(0x60)
    5852
                m4 := mload(0x80)
    5853
                // Selector of `log(bool,address,uint256,address)`.
    5854
                mstore(0x00, 0x136b05dd)
    5855
                mstore(0x20, p0)
    5856
                mstore(0x40, p1)
    5857
                mstore(0x60, p2)
    5858
                mstore(0x80, p3)
    5859
            }
    5860
            _sendLogPayload(0x1c, 0x84);
    5861
            /// @solidity memory-safe-assembly
    5862
            assembly {
    5863
                mstore(0x00, m0)
    5864
                mstore(0x20, m1)
    5865
                mstore(0x40, m2)
    5866
                mstore(0x60, m3)
    5867
                mstore(0x80, m4)
    5868
            }
    5869
        }
    5870
    
                                                    
                                                
    5871
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    5872
            bytes32 m0;
    5873
            bytes32 m1;
    5874
            bytes32 m2;
    5875
            bytes32 m3;
    5876
            bytes32 m4;
    5877
            /// @solidity memory-safe-assembly
    5878
            assembly {
    5879
                m0 := mload(0x00)
    5880
                m1 := mload(0x20)
    5881
                m2 := mload(0x40)
    5882
                m3 := mload(0x60)
    5883
                m4 := mload(0x80)
    5884
                // Selector of `log(bool,address,uint256,bool)`.
    5885
                mstore(0x00, 0xd6019f1c)
    5886
                mstore(0x20, p0)
    5887
                mstore(0x40, p1)
    5888
                mstore(0x60, p2)
    5889
                mstore(0x80, p3)
    5890
            }
    5891
            _sendLogPayload(0x1c, 0x84);
    5892
            /// @solidity memory-safe-assembly
    5893
            assembly {
    5894
                mstore(0x00, m0)
    5895
                mstore(0x20, m1)
    5896
                mstore(0x40, m2)
    5897
                mstore(0x60, m3)
    5898
                mstore(0x80, m4)
    5899
            }
    5900
        }
    5901
    
                                                    
                                                
    5902
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    5903
            bytes32 m0;
    5904
            bytes32 m1;
    5905
            bytes32 m2;
    5906
            bytes32 m3;
    5907
            bytes32 m4;
    5908
            /// @solidity memory-safe-assembly
    5909
            assembly {
    5910
                m0 := mload(0x00)
    5911
                m1 := mload(0x20)
    5912
                m2 := mload(0x40)
    5913
                m3 := mload(0x60)
    5914
                m4 := mload(0x80)
    5915
                // Selector of `log(bool,address,uint256,uint256)`.
    5916
                mstore(0x00, 0x7bf181a1)
    5917
                mstore(0x20, p0)
    5918
                mstore(0x40, p1)
    5919
                mstore(0x60, p2)
    5920
                mstore(0x80, p3)
    5921
            }
    5922
            _sendLogPayload(0x1c, 0x84);
    5923
            /// @solidity memory-safe-assembly
    5924
            assembly {
    5925
                mstore(0x00, m0)
    5926
                mstore(0x20, m1)
    5927
                mstore(0x40, m2)
    5928
                mstore(0x60, m3)
    5929
                mstore(0x80, m4)
    5930
            }
    5931
        }
    5932
    
                                                    
                                                
    5933
        function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {
    5934
            bytes32 m0;
    5935
            bytes32 m1;
    5936
            bytes32 m2;
    5937
            bytes32 m3;
    5938
            bytes32 m4;
    5939
            bytes32 m5;
    5940
            bytes32 m6;
    5941
            /// @solidity memory-safe-assembly
    5942
            assembly {
    5943
                function writeString(pos, w) {
    5944
                    let length := 0
    5945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5946
                    mstore(pos, length)
    5947
                    let shift := sub(256, shl(3, length))
    5948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5949
                }
    5950
                m0 := mload(0x00)
    5951
                m1 := mload(0x20)
    5952
                m2 := mload(0x40)
    5953
                m3 := mload(0x60)
    5954
                m4 := mload(0x80)
    5955
                m5 := mload(0xa0)
    5956
                m6 := mload(0xc0)
    5957
                // Selector of `log(bool,address,uint256,string)`.
    5958
                mstore(0x00, 0x51f09ff8)
    5959
                mstore(0x20, p0)
    5960
                mstore(0x40, p1)
    5961
                mstore(0x60, p2)
    5962
                mstore(0x80, 0x80)
    5963
                writeString(0xa0, p3)
    5964
            }
    5965
            _sendLogPayload(0x1c, 0xc4);
    5966
            /// @solidity memory-safe-assembly
    5967
            assembly {
    5968
                mstore(0x00, m0)
    5969
                mstore(0x20, m1)
    5970
                mstore(0x40, m2)
    5971
                mstore(0x60, m3)
    5972
                mstore(0x80, m4)
    5973
                mstore(0xa0, m5)
    5974
                mstore(0xc0, m6)
    5975
            }
    5976
        }
    5977
    
                                                    
                                                
    5978
        function log(bool p0, address p1, bytes32 p2, address p3) internal pure {
    5979
            bytes32 m0;
    5980
            bytes32 m1;
    5981
            bytes32 m2;
    5982
            bytes32 m3;
    5983
            bytes32 m4;
    5984
            bytes32 m5;
    5985
            bytes32 m6;
    5986
            /// @solidity memory-safe-assembly
    5987
            assembly {
    5988
                function writeString(pos, w) {
    5989
                    let length := 0
    5990
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5991
                    mstore(pos, length)
    5992
                    let shift := sub(256, shl(3, length))
    5993
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5994
                }
    5995
                m0 := mload(0x00)
    5996
                m1 := mload(0x20)
    5997
                m2 := mload(0x40)
    5998
                m3 := mload(0x60)
    5999
                m4 := mload(0x80)
    6000
                m5 := mload(0xa0)
    6001
                m6 := mload(0xc0)
    6002
                // Selector of `log(bool,address,string,address)`.
    6003
                mstore(0x00, 0x6f7c603e)
    6004
                mstore(0x20, p0)
    6005
                mstore(0x40, p1)
    6006
                mstore(0x60, 0x80)
    6007
                mstore(0x80, p3)
    6008
                writeString(0xa0, p2)
    6009
            }
    6010
            _sendLogPayload(0x1c, 0xc4);
    6011
            /// @solidity memory-safe-assembly
    6012
            assembly {
    6013
                mstore(0x00, m0)
    6014
                mstore(0x20, m1)
    6015
                mstore(0x40, m2)
    6016
                mstore(0x60, m3)
    6017
                mstore(0x80, m4)
    6018
                mstore(0xa0, m5)
    6019
                mstore(0xc0, m6)
    6020
            }
    6021
        }
    6022
    
                                                    
                                                
    6023
        function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {
    6024
            bytes32 m0;
    6025
            bytes32 m1;
    6026
            bytes32 m2;
    6027
            bytes32 m3;
    6028
            bytes32 m4;
    6029
            bytes32 m5;
    6030
            bytes32 m6;
    6031
            /// @solidity memory-safe-assembly
    6032
            assembly {
    6033
                function writeString(pos, w) {
    6034
                    let length := 0
    6035
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6036
                    mstore(pos, length)
    6037
                    let shift := sub(256, shl(3, length))
    6038
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6039
                }
    6040
                m0 := mload(0x00)
    6041
                m1 := mload(0x20)
    6042
                m2 := mload(0x40)
    6043
                m3 := mload(0x60)
    6044
                m4 := mload(0x80)
    6045
                m5 := mload(0xa0)
    6046
                m6 := mload(0xc0)
    6047
                // Selector of `log(bool,address,string,bool)`.
    6048
                mstore(0x00, 0xe2bfd60b)
    6049
                mstore(0x20, p0)
    6050
                mstore(0x40, p1)
    6051
                mstore(0x60, 0x80)
    6052
                mstore(0x80, p3)
    6053
                writeString(0xa0, p2)
    6054
            }
    6055
            _sendLogPayload(0x1c, 0xc4);
    6056
            /// @solidity memory-safe-assembly
    6057
            assembly {
    6058
                mstore(0x00, m0)
    6059
                mstore(0x20, m1)
    6060
                mstore(0x40, m2)
    6061
                mstore(0x60, m3)
    6062
                mstore(0x80, m4)
    6063
                mstore(0xa0, m5)
    6064
                mstore(0xc0, m6)
    6065
            }
    6066
        }
    6067
    
                                                    
                                                
    6068
        function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {
    6069
            bytes32 m0;
    6070
            bytes32 m1;
    6071
            bytes32 m2;
    6072
            bytes32 m3;
    6073
            bytes32 m4;
    6074
            bytes32 m5;
    6075
            bytes32 m6;
    6076
            /// @solidity memory-safe-assembly
    6077
            assembly {
    6078
                function writeString(pos, w) {
    6079
                    let length := 0
    6080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6081
                    mstore(pos, length)
    6082
                    let shift := sub(256, shl(3, length))
    6083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6084
                }
    6085
                m0 := mload(0x00)
    6086
                m1 := mload(0x20)
    6087
                m2 := mload(0x40)
    6088
                m3 := mload(0x60)
    6089
                m4 := mload(0x80)
    6090
                m5 := mload(0xa0)
    6091
                m6 := mload(0xc0)
    6092
                // Selector of `log(bool,address,string,uint256)`.
    6093
                mstore(0x00, 0xc21f64c7)
    6094
                mstore(0x20, p0)
    6095
                mstore(0x40, p1)
    6096
                mstore(0x60, 0x80)
    6097
                mstore(0x80, p3)
    6098
                writeString(0xa0, p2)
    6099
            }
    6100
            _sendLogPayload(0x1c, 0xc4);
    6101
            /// @solidity memory-safe-assembly
    6102
            assembly {
    6103
                mstore(0x00, m0)
    6104
                mstore(0x20, m1)
    6105
                mstore(0x40, m2)
    6106
                mstore(0x60, m3)
    6107
                mstore(0x80, m4)
    6108
                mstore(0xa0, m5)
    6109
                mstore(0xc0, m6)
    6110
            }
    6111
        }
    6112
    
                                                    
                                                
    6113
        function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    6114
            bytes32 m0;
    6115
            bytes32 m1;
    6116
            bytes32 m2;
    6117
            bytes32 m3;
    6118
            bytes32 m4;
    6119
            bytes32 m5;
    6120
            bytes32 m6;
    6121
            bytes32 m7;
    6122
            bytes32 m8;
    6123
            /// @solidity memory-safe-assembly
    6124
            assembly {
    6125
                function writeString(pos, w) {
    6126
                    let length := 0
    6127
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6128
                    mstore(pos, length)
    6129
                    let shift := sub(256, shl(3, length))
    6130
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6131
                }
    6132
                m0 := mload(0x00)
    6133
                m1 := mload(0x20)
    6134
                m2 := mload(0x40)
    6135
                m3 := mload(0x60)
    6136
                m4 := mload(0x80)
    6137
                m5 := mload(0xa0)
    6138
                m6 := mload(0xc0)
    6139
                m7 := mload(0xe0)
    6140
                m8 := mload(0x100)
    6141
                // Selector of `log(bool,address,string,string)`.
    6142
                mstore(0x00, 0xa73c1db6)
    6143
                mstore(0x20, p0)
    6144
                mstore(0x40, p1)
    6145
                mstore(0x60, 0x80)
    6146
                mstore(0x80, 0xc0)
    6147
                writeString(0xa0, p2)
    6148
                writeString(0xe0, p3)
    6149
            }
    6150
            _sendLogPayload(0x1c, 0x104);
    6151
            /// @solidity memory-safe-assembly
    6152
            assembly {
    6153
                mstore(0x00, m0)
    6154
                mstore(0x20, m1)
    6155
                mstore(0x40, m2)
    6156
                mstore(0x60, m3)
    6157
                mstore(0x80, m4)
    6158
                mstore(0xa0, m5)
    6159
                mstore(0xc0, m6)
    6160
                mstore(0xe0, m7)
    6161
                mstore(0x100, m8)
    6162
            }
    6163
        }
    6164
    
                                                    
                                                
    6165
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    6166
            bytes32 m0;
    6167
            bytes32 m1;
    6168
            bytes32 m2;
    6169
            bytes32 m3;
    6170
            bytes32 m4;
    6171
            /// @solidity memory-safe-assembly
    6172
            assembly {
    6173
                m0 := mload(0x00)
    6174
                m1 := mload(0x20)
    6175
                m2 := mload(0x40)
    6176
                m3 := mload(0x60)
    6177
                m4 := mload(0x80)
    6178
                // Selector of `log(bool,bool,address,address)`.
    6179
                mstore(0x00, 0xf4880ea4)
    6180
                mstore(0x20, p0)
    6181
                mstore(0x40, p1)
    6182
                mstore(0x60, p2)
    6183
                mstore(0x80, p3)
    6184
            }
    6185
            _sendLogPayload(0x1c, 0x84);
    6186
            /// @solidity memory-safe-assembly
    6187
            assembly {
    6188
                mstore(0x00, m0)
    6189
                mstore(0x20, m1)
    6190
                mstore(0x40, m2)
    6191
                mstore(0x60, m3)
    6192
                mstore(0x80, m4)
    6193
            }
    6194
        }
    6195
    
                                                    
                                                
    6196
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    6197
            bytes32 m0;
    6198
            bytes32 m1;
    6199
            bytes32 m2;
    6200
            bytes32 m3;
    6201
            bytes32 m4;
    6202
            /// @solidity memory-safe-assembly
    6203
            assembly {
    6204
                m0 := mload(0x00)
    6205
                m1 := mload(0x20)
    6206
                m2 := mload(0x40)
    6207
                m3 := mload(0x60)
    6208
                m4 := mload(0x80)
    6209
                // Selector of `log(bool,bool,address,bool)`.
    6210
                mstore(0x00, 0xc0a302d8)
    6211
                mstore(0x20, p0)
    6212
                mstore(0x40, p1)
    6213
                mstore(0x60, p2)
    6214
                mstore(0x80, p3)
    6215
            }
    6216
            _sendLogPayload(0x1c, 0x84);
    6217
            /// @solidity memory-safe-assembly
    6218
            assembly {
    6219
                mstore(0x00, m0)
    6220
                mstore(0x20, m1)
    6221
                mstore(0x40, m2)
    6222
                mstore(0x60, m3)
    6223
                mstore(0x80, m4)
    6224
            }
    6225
        }
    6226
    
                                                    
                                                
    6227
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    6228
            bytes32 m0;
    6229
            bytes32 m1;
    6230
            bytes32 m2;
    6231
            bytes32 m3;
    6232
            bytes32 m4;
    6233
            /// @solidity memory-safe-assembly
    6234
            assembly {
    6235
                m0 := mload(0x00)
    6236
                m1 := mload(0x20)
    6237
                m2 := mload(0x40)
    6238
                m3 := mload(0x60)
    6239
                m4 := mload(0x80)
    6240
                // Selector of `log(bool,bool,address,uint256)`.
    6241
                mstore(0x00, 0x4c123d57)
    6242
                mstore(0x20, p0)
    6243
                mstore(0x40, p1)
    6244
                mstore(0x60, p2)
    6245
                mstore(0x80, p3)
    6246
            }
    6247
            _sendLogPayload(0x1c, 0x84);
    6248
            /// @solidity memory-safe-assembly
    6249
            assembly {
    6250
                mstore(0x00, m0)
    6251
                mstore(0x20, m1)
    6252
                mstore(0x40, m2)
    6253
                mstore(0x60, m3)
    6254
                mstore(0x80, m4)
    6255
            }
    6256
        }
    6257
    
                                                    
                                                
    6258
        function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {
    6259
            bytes32 m0;
    6260
            bytes32 m1;
    6261
            bytes32 m2;
    6262
            bytes32 m3;
    6263
            bytes32 m4;
    6264
            bytes32 m5;
    6265
            bytes32 m6;
    6266
            /// @solidity memory-safe-assembly
    6267
            assembly {
    6268
                function writeString(pos, w) {
    6269
                    let length := 0
    6270
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6271
                    mstore(pos, length)
    6272
                    let shift := sub(256, shl(3, length))
    6273
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6274
                }
    6275
                m0 := mload(0x00)
    6276
                m1 := mload(0x20)
    6277
                m2 := mload(0x40)
    6278
                m3 := mload(0x60)
    6279
                m4 := mload(0x80)
    6280
                m5 := mload(0xa0)
    6281
                m6 := mload(0xc0)
    6282
                // Selector of `log(bool,bool,address,string)`.
    6283
                mstore(0x00, 0xa0a47963)
    6284
                mstore(0x20, p0)
    6285
                mstore(0x40, p1)
    6286
                mstore(0x60, p2)
    6287
                mstore(0x80, 0x80)
    6288
                writeString(0xa0, p3)
    6289
            }
    6290
            _sendLogPayload(0x1c, 0xc4);
    6291
            /// @solidity memory-safe-assembly
    6292
            assembly {
    6293
                mstore(0x00, m0)
    6294
                mstore(0x20, m1)
    6295
                mstore(0x40, m2)
    6296
                mstore(0x60, m3)
    6297
                mstore(0x80, m4)
    6298
                mstore(0xa0, m5)
    6299
                mstore(0xc0, m6)
    6300
            }
    6301
        }
    6302
    
                                                    
                                                
    6303
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    6304
            bytes32 m0;
    6305
            bytes32 m1;
    6306
            bytes32 m2;
    6307
            bytes32 m3;
    6308
            bytes32 m4;
    6309
            /// @solidity memory-safe-assembly
    6310
            assembly {
    6311
                m0 := mload(0x00)
    6312
                m1 := mload(0x20)
    6313
                m2 := mload(0x40)
    6314
                m3 := mload(0x60)
    6315
                m4 := mload(0x80)
    6316
                // Selector of `log(bool,bool,bool,address)`.
    6317
                mstore(0x00, 0x8c329b1a)
    6318
                mstore(0x20, p0)
    6319
                mstore(0x40, p1)
    6320
                mstore(0x60, p2)
    6321
                mstore(0x80, p3)
    6322
            }
    6323
            _sendLogPayload(0x1c, 0x84);
    6324
            /// @solidity memory-safe-assembly
    6325
            assembly {
    6326
                mstore(0x00, m0)
    6327
                mstore(0x20, m1)
    6328
                mstore(0x40, m2)
    6329
                mstore(0x60, m3)
    6330
                mstore(0x80, m4)
    6331
            }
    6332
        }
    6333
    
                                                    
                                                
    6334
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    6335
            bytes32 m0;
    6336
            bytes32 m1;
    6337
            bytes32 m2;
    6338
            bytes32 m3;
    6339
            bytes32 m4;
    6340
            /// @solidity memory-safe-assembly
    6341
            assembly {
    6342
                m0 := mload(0x00)
    6343
                m1 := mload(0x20)
    6344
                m2 := mload(0x40)
    6345
                m3 := mload(0x60)
    6346
                m4 := mload(0x80)
    6347
                // Selector of `log(bool,bool,bool,bool)`.
    6348
                mstore(0x00, 0x3b2a5ce0)
    6349
                mstore(0x20, p0)
    6350
                mstore(0x40, p1)
    6351
                mstore(0x60, p2)
    6352
                mstore(0x80, p3)
    6353
            }
    6354
            _sendLogPayload(0x1c, 0x84);
    6355
            /// @solidity memory-safe-assembly
    6356
            assembly {
    6357
                mstore(0x00, m0)
    6358
                mstore(0x20, m1)
    6359
                mstore(0x40, m2)
    6360
                mstore(0x60, m3)
    6361
                mstore(0x80, m4)
    6362
            }
    6363
        }
    6364
    
                                                    
                                                
    6365
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    6366
            bytes32 m0;
    6367
            bytes32 m1;
    6368
            bytes32 m2;
    6369
            bytes32 m3;
    6370
            bytes32 m4;
    6371
            /// @solidity memory-safe-assembly
    6372
            assembly {
    6373
                m0 := mload(0x00)
    6374
                m1 := mload(0x20)
    6375
                m2 := mload(0x40)
    6376
                m3 := mload(0x60)
    6377
                m4 := mload(0x80)
    6378
                // Selector of `log(bool,bool,bool,uint256)`.
    6379
                mstore(0x00, 0x6d7045c1)
    6380
                mstore(0x20, p0)
    6381
                mstore(0x40, p1)
    6382
                mstore(0x60, p2)
    6383
                mstore(0x80, p3)
    6384
            }
    6385
            _sendLogPayload(0x1c, 0x84);
    6386
            /// @solidity memory-safe-assembly
    6387
            assembly {
    6388
                mstore(0x00, m0)
    6389
                mstore(0x20, m1)
    6390
                mstore(0x40, m2)
    6391
                mstore(0x60, m3)
    6392
                mstore(0x80, m4)
    6393
            }
    6394
        }
    6395
    
                                                    
                                                
    6396
        function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {
    6397
            bytes32 m0;
    6398
            bytes32 m1;
    6399
            bytes32 m2;
    6400
            bytes32 m3;
    6401
            bytes32 m4;
    6402
            bytes32 m5;
    6403
            bytes32 m6;
    6404
            /// @solidity memory-safe-assembly
    6405
            assembly {
    6406
                function writeString(pos, w) {
    6407
                    let length := 0
    6408
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6409
                    mstore(pos, length)
    6410
                    let shift := sub(256, shl(3, length))
    6411
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6412
                }
    6413
                m0 := mload(0x00)
    6414
                m1 := mload(0x20)
    6415
                m2 := mload(0x40)
    6416
                m3 := mload(0x60)
    6417
                m4 := mload(0x80)
    6418
                m5 := mload(0xa0)
    6419
                m6 := mload(0xc0)
    6420
                // Selector of `log(bool,bool,bool,string)`.
    6421
                mstore(0x00, 0x2ae408d4)
    6422
                mstore(0x20, p0)
    6423
                mstore(0x40, p1)
    6424
                mstore(0x60, p2)
    6425
                mstore(0x80, 0x80)
    6426
                writeString(0xa0, p3)
    6427
            }
    6428
            _sendLogPayload(0x1c, 0xc4);
    6429
            /// @solidity memory-safe-assembly
    6430
            assembly {
    6431
                mstore(0x00, m0)
    6432
                mstore(0x20, m1)
    6433
                mstore(0x40, m2)
    6434
                mstore(0x60, m3)
    6435
                mstore(0x80, m4)
    6436
                mstore(0xa0, m5)
    6437
                mstore(0xc0, m6)
    6438
            }
    6439
        }
    6440
    
                                                    
                                                
    6441
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    6442
            bytes32 m0;
    6443
            bytes32 m1;
    6444
            bytes32 m2;
    6445
            bytes32 m3;
    6446
            bytes32 m4;
    6447
            /// @solidity memory-safe-assembly
    6448
            assembly {
    6449
                m0 := mload(0x00)
    6450
                m1 := mload(0x20)
    6451
                m2 := mload(0x40)
    6452
                m3 := mload(0x60)
    6453
                m4 := mload(0x80)
    6454
                // Selector of `log(bool,bool,uint256,address)`.
    6455
                mstore(0x00, 0x54a7a9a0)
    6456
                mstore(0x20, p0)
    6457
                mstore(0x40, p1)
    6458
                mstore(0x60, p2)
    6459
                mstore(0x80, p3)
    6460
            }
    6461
            _sendLogPayload(0x1c, 0x84);
    6462
            /// @solidity memory-safe-assembly
    6463
            assembly {
    6464
                mstore(0x00, m0)
    6465
                mstore(0x20, m1)
    6466
                mstore(0x40, m2)
    6467
                mstore(0x60, m3)
    6468
                mstore(0x80, m4)
    6469
            }
    6470
        }
    6471
    
                                                    
                                                
    6472
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    6473
            bytes32 m0;
    6474
            bytes32 m1;
    6475
            bytes32 m2;
    6476
            bytes32 m3;
    6477
            bytes32 m4;
    6478
            /// @solidity memory-safe-assembly
    6479
            assembly {
    6480
                m0 := mload(0x00)
    6481
                m1 := mload(0x20)
    6482
                m2 := mload(0x40)
    6483
                m3 := mload(0x60)
    6484
                m4 := mload(0x80)
    6485
                // Selector of `log(bool,bool,uint256,bool)`.
    6486
                mstore(0x00, 0x619e4d0e)
    6487
                mstore(0x20, p0)
    6488
                mstore(0x40, p1)
    6489
                mstore(0x60, p2)
    6490
                mstore(0x80, p3)
    6491
            }
    6492
            _sendLogPayload(0x1c, 0x84);
    6493
            /// @solidity memory-safe-assembly
    6494
            assembly {
    6495
                mstore(0x00, m0)
    6496
                mstore(0x20, m1)
    6497
                mstore(0x40, m2)
    6498
                mstore(0x60, m3)
    6499
                mstore(0x80, m4)
    6500
            }
    6501
        }
    6502
    
                                                    
                                                
    6503
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    6504
            bytes32 m0;
    6505
            bytes32 m1;
    6506
            bytes32 m2;
    6507
            bytes32 m3;
    6508
            bytes32 m4;
    6509
            /// @solidity memory-safe-assembly
    6510
            assembly {
    6511
                m0 := mload(0x00)
    6512
                m1 := mload(0x20)
    6513
                m2 := mload(0x40)
    6514
                m3 := mload(0x60)
    6515
                m4 := mload(0x80)
    6516
                // Selector of `log(bool,bool,uint256,uint256)`.
    6517
                mstore(0x00, 0x0bb00eab)
    6518
                mstore(0x20, p0)
    6519
                mstore(0x40, p1)
    6520
                mstore(0x60, p2)
    6521
                mstore(0x80, p3)
    6522
            }
    6523
            _sendLogPayload(0x1c, 0x84);
    6524
            /// @solidity memory-safe-assembly
    6525
            assembly {
    6526
                mstore(0x00, m0)
    6527
                mstore(0x20, m1)
    6528
                mstore(0x40, m2)
    6529
                mstore(0x60, m3)
    6530
                mstore(0x80, m4)
    6531
            }
    6532
        }
    6533
    
                                                    
                                                
    6534
        function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    6535
            bytes32 m0;
    6536
            bytes32 m1;
    6537
            bytes32 m2;
    6538
            bytes32 m3;
    6539
            bytes32 m4;
    6540
            bytes32 m5;
    6541
            bytes32 m6;
    6542
            /// @solidity memory-safe-assembly
    6543
            assembly {
    6544
                function writeString(pos, w) {
    6545
                    let length := 0
    6546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6547
                    mstore(pos, length)
    6548
                    let shift := sub(256, shl(3, length))
    6549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6550
                }
    6551
                m0 := mload(0x00)
    6552
                m1 := mload(0x20)
    6553
                m2 := mload(0x40)
    6554
                m3 := mload(0x60)
    6555
                m4 := mload(0x80)
    6556
                m5 := mload(0xa0)
    6557
                m6 := mload(0xc0)
    6558
                // Selector of `log(bool,bool,uint256,string)`.
    6559
                mstore(0x00, 0x7dd4d0e0)
    6560
                mstore(0x20, p0)
    6561
                mstore(0x40, p1)
    6562
                mstore(0x60, p2)
    6563
                mstore(0x80, 0x80)
    6564
                writeString(0xa0, p3)
    6565
            }
    6566
            _sendLogPayload(0x1c, 0xc4);
    6567
            /// @solidity memory-safe-assembly
    6568
            assembly {
    6569
                mstore(0x00, m0)
    6570
                mstore(0x20, m1)
    6571
                mstore(0x40, m2)
    6572
                mstore(0x60, m3)
    6573
                mstore(0x80, m4)
    6574
                mstore(0xa0, m5)
    6575
                mstore(0xc0, m6)
    6576
            }
    6577
        }
    6578
    
                                                    
                                                
    6579
        function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {
    6580
            bytes32 m0;
    6581
            bytes32 m1;
    6582
            bytes32 m2;
    6583
            bytes32 m3;
    6584
            bytes32 m4;
    6585
            bytes32 m5;
    6586
            bytes32 m6;
    6587
            /// @solidity memory-safe-assembly
    6588
            assembly {
    6589
                function writeString(pos, w) {
    6590
                    let length := 0
    6591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6592
                    mstore(pos, length)
    6593
                    let shift := sub(256, shl(3, length))
    6594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6595
                }
    6596
                m0 := mload(0x00)
    6597
                m1 := mload(0x20)
    6598
                m2 := mload(0x40)
    6599
                m3 := mload(0x60)
    6600
                m4 := mload(0x80)
    6601
                m5 := mload(0xa0)
    6602
                m6 := mload(0xc0)
    6603
                // Selector of `log(bool,bool,string,address)`.
    6604
                mstore(0x00, 0xf9ad2b89)
    6605
                mstore(0x20, p0)
    6606
                mstore(0x40, p1)
    6607
                mstore(0x60, 0x80)
    6608
                mstore(0x80, p3)
    6609
                writeString(0xa0, p2)
    6610
            }
    6611
            _sendLogPayload(0x1c, 0xc4);
    6612
            /// @solidity memory-safe-assembly
    6613
            assembly {
    6614
                mstore(0x00, m0)
    6615
                mstore(0x20, m1)
    6616
                mstore(0x40, m2)
    6617
                mstore(0x60, m3)
    6618
                mstore(0x80, m4)
    6619
                mstore(0xa0, m5)
    6620
                mstore(0xc0, m6)
    6621
            }
    6622
        }
    6623
    
                                                    
                                                
    6624
        function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {
    6625
            bytes32 m0;
    6626
            bytes32 m1;
    6627
            bytes32 m2;
    6628
            bytes32 m3;
    6629
            bytes32 m4;
    6630
            bytes32 m5;
    6631
            bytes32 m6;
    6632
            /// @solidity memory-safe-assembly
    6633
            assembly {
    6634
                function writeString(pos, w) {
    6635
                    let length := 0
    6636
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6637
                    mstore(pos, length)
    6638
                    let shift := sub(256, shl(3, length))
    6639
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6640
                }
    6641
                m0 := mload(0x00)
    6642
                m1 := mload(0x20)
    6643
                m2 := mload(0x40)
    6644
                m3 := mload(0x60)
    6645
                m4 := mload(0x80)
    6646
                m5 := mload(0xa0)
    6647
                m6 := mload(0xc0)
    6648
                // Selector of `log(bool,bool,string,bool)`.
    6649
                mstore(0x00, 0xb857163a)
    6650
                mstore(0x20, p0)
    6651
                mstore(0x40, p1)
    6652
                mstore(0x60, 0x80)
    6653
                mstore(0x80, p3)
    6654
                writeString(0xa0, p2)
    6655
            }
    6656
            _sendLogPayload(0x1c, 0xc4);
    6657
            /// @solidity memory-safe-assembly
    6658
            assembly {
    6659
                mstore(0x00, m0)
    6660
                mstore(0x20, m1)
    6661
                mstore(0x40, m2)
    6662
                mstore(0x60, m3)
    6663
                mstore(0x80, m4)
    6664
                mstore(0xa0, m5)
    6665
                mstore(0xc0, m6)
    6666
            }
    6667
        }
    6668
    
                                                    
                                                
    6669
        function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    6670
            bytes32 m0;
    6671
            bytes32 m1;
    6672
            bytes32 m2;
    6673
            bytes32 m3;
    6674
            bytes32 m4;
    6675
            bytes32 m5;
    6676
            bytes32 m6;
    6677
            /// @solidity memory-safe-assembly
    6678
            assembly {
    6679
                function writeString(pos, w) {
    6680
                    let length := 0
    6681
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6682
                    mstore(pos, length)
    6683
                    let shift := sub(256, shl(3, length))
    6684
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6685
                }
    6686
                m0 := mload(0x00)
    6687
                m1 := mload(0x20)
    6688
                m2 := mload(0x40)
    6689
                m3 := mload(0x60)
    6690
                m4 := mload(0x80)
    6691
                m5 := mload(0xa0)
    6692
                m6 := mload(0xc0)
    6693
                // Selector of `log(bool,bool,string,uint256)`.
    6694
                mstore(0x00, 0xe3a9ca2f)
    6695
                mstore(0x20, p0)
    6696
                mstore(0x40, p1)
    6697
                mstore(0x60, 0x80)
    6698
                mstore(0x80, p3)
    6699
                writeString(0xa0, p2)
    6700
            }
    6701
            _sendLogPayload(0x1c, 0xc4);
    6702
            /// @solidity memory-safe-assembly
    6703
            assembly {
    6704
                mstore(0x00, m0)
    6705
                mstore(0x20, m1)
    6706
                mstore(0x40, m2)
    6707
                mstore(0x60, m3)
    6708
                mstore(0x80, m4)
    6709
                mstore(0xa0, m5)
    6710
                mstore(0xc0, m6)
    6711
            }
    6712
        }
    6713
    
                                                    
                                                
    6714
        function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    6715
            bytes32 m0;
    6716
            bytes32 m1;
    6717
            bytes32 m2;
    6718
            bytes32 m3;
    6719
            bytes32 m4;
    6720
            bytes32 m5;
    6721
            bytes32 m6;
    6722
            bytes32 m7;
    6723
            bytes32 m8;
    6724
            /// @solidity memory-safe-assembly
    6725
            assembly {
    6726
                function writeString(pos, w) {
    6727
                    let length := 0
    6728
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6729
                    mstore(pos, length)
    6730
                    let shift := sub(256, shl(3, length))
    6731
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6732
                }
    6733
                m0 := mload(0x00)
    6734
                m1 := mload(0x20)
    6735
                m2 := mload(0x40)
    6736
                m3 := mload(0x60)
    6737
                m4 := mload(0x80)
    6738
                m5 := mload(0xa0)
    6739
                m6 := mload(0xc0)
    6740
                m7 := mload(0xe0)
    6741
                m8 := mload(0x100)
    6742
                // Selector of `log(bool,bool,string,string)`.
    6743
                mstore(0x00, 0x6d1e8751)
    6744
                mstore(0x20, p0)
    6745
                mstore(0x40, p1)
    6746
                mstore(0x60, 0x80)
    6747
                mstore(0x80, 0xc0)
    6748
                writeString(0xa0, p2)
    6749
                writeString(0xe0, p3)
    6750
            }
    6751
            _sendLogPayload(0x1c, 0x104);
    6752
            /// @solidity memory-safe-assembly
    6753
            assembly {
    6754
                mstore(0x00, m0)
    6755
                mstore(0x20, m1)
    6756
                mstore(0x40, m2)
    6757
                mstore(0x60, m3)
    6758
                mstore(0x80, m4)
    6759
                mstore(0xa0, m5)
    6760
                mstore(0xc0, m6)
    6761
                mstore(0xe0, m7)
    6762
                mstore(0x100, m8)
    6763
            }
    6764
        }
    6765
    
                                                    
                                                
    6766
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    6767
            bytes32 m0;
    6768
            bytes32 m1;
    6769
            bytes32 m2;
    6770
            bytes32 m3;
    6771
            bytes32 m4;
    6772
            /// @solidity memory-safe-assembly
    6773
            assembly {
    6774
                m0 := mload(0x00)
    6775
                m1 := mload(0x20)
    6776
                m2 := mload(0x40)
    6777
                m3 := mload(0x60)
    6778
                m4 := mload(0x80)
    6779
                // Selector of `log(bool,uint256,address,address)`.
    6780
                mstore(0x00, 0x26f560a8)
    6781
                mstore(0x20, p0)
    6782
                mstore(0x40, p1)
    6783
                mstore(0x60, p2)
    6784
                mstore(0x80, p3)
    6785
            }
    6786
            _sendLogPayload(0x1c, 0x84);
    6787
            /// @solidity memory-safe-assembly
    6788
            assembly {
    6789
                mstore(0x00, m0)
    6790
                mstore(0x20, m1)
    6791
                mstore(0x40, m2)
    6792
                mstore(0x60, m3)
    6793
                mstore(0x80, m4)
    6794
            }
    6795
        }
    6796
    
                                                    
                                                
    6797
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    6798
            bytes32 m0;
    6799
            bytes32 m1;
    6800
            bytes32 m2;
    6801
            bytes32 m3;
    6802
            bytes32 m4;
    6803
            /// @solidity memory-safe-assembly
    6804
            assembly {
    6805
                m0 := mload(0x00)
    6806
                m1 := mload(0x20)
    6807
                m2 := mload(0x40)
    6808
                m3 := mload(0x60)
    6809
                m4 := mload(0x80)
    6810
                // Selector of `log(bool,uint256,address,bool)`.
    6811
                mstore(0x00, 0xb4c314ff)
    6812
                mstore(0x20, p0)
    6813
                mstore(0x40, p1)
    6814
                mstore(0x60, p2)
    6815
                mstore(0x80, p3)
    6816
            }
    6817
            _sendLogPayload(0x1c, 0x84);
    6818
            /// @solidity memory-safe-assembly
    6819
            assembly {
    6820
                mstore(0x00, m0)
    6821
                mstore(0x20, m1)
    6822
                mstore(0x40, m2)
    6823
                mstore(0x60, m3)
    6824
                mstore(0x80, m4)
    6825
            }
    6826
        }
    6827
    
                                                    
                                                
    6828
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    6829
            bytes32 m0;
    6830
            bytes32 m1;
    6831
            bytes32 m2;
    6832
            bytes32 m3;
    6833
            bytes32 m4;
    6834
            /// @solidity memory-safe-assembly
    6835
            assembly {
    6836
                m0 := mload(0x00)
    6837
                m1 := mload(0x20)
    6838
                m2 := mload(0x40)
    6839
                m3 := mload(0x60)
    6840
                m4 := mload(0x80)
    6841
                // Selector of `log(bool,uint256,address,uint256)`.
    6842
                mstore(0x00, 0x1537dc87)
    6843
                mstore(0x20, p0)
    6844
                mstore(0x40, p1)
    6845
                mstore(0x60, p2)
    6846
                mstore(0x80, p3)
    6847
            }
    6848
            _sendLogPayload(0x1c, 0x84);
    6849
            /// @solidity memory-safe-assembly
    6850
            assembly {
    6851
                mstore(0x00, m0)
    6852
                mstore(0x20, m1)
    6853
                mstore(0x40, m2)
    6854
                mstore(0x60, m3)
    6855
                mstore(0x80, m4)
    6856
            }
    6857
        }
    6858
    
                                                    
                                                
    6859
        function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {
    6860
            bytes32 m0;
    6861
            bytes32 m1;
    6862
            bytes32 m2;
    6863
            bytes32 m3;
    6864
            bytes32 m4;
    6865
            bytes32 m5;
    6866
            bytes32 m6;
    6867
            /// @solidity memory-safe-assembly
    6868
            assembly {
    6869
                function writeString(pos, w) {
    6870
                    let length := 0
    6871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6872
                    mstore(pos, length)
    6873
                    let shift := sub(256, shl(3, length))
    6874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6875
                }
    6876
                m0 := mload(0x00)
    6877
                m1 := mload(0x20)
    6878
                m2 := mload(0x40)
    6879
                m3 := mload(0x60)
    6880
                m4 := mload(0x80)
    6881
                m5 := mload(0xa0)
    6882
                m6 := mload(0xc0)
    6883
                // Selector of `log(bool,uint256,address,string)`.
    6884
                mstore(0x00, 0x1bb3b09a)
    6885
                mstore(0x20, p0)
    6886
                mstore(0x40, p1)
    6887
                mstore(0x60, p2)
    6888
                mstore(0x80, 0x80)
    6889
                writeString(0xa0, p3)
    6890
            }
    6891
            _sendLogPayload(0x1c, 0xc4);
    6892
            /// @solidity memory-safe-assembly
    6893
            assembly {
    6894
                mstore(0x00, m0)
    6895
                mstore(0x20, m1)
    6896
                mstore(0x40, m2)
    6897
                mstore(0x60, m3)
    6898
                mstore(0x80, m4)
    6899
                mstore(0xa0, m5)
    6900
                mstore(0xc0, m6)
    6901
            }
    6902
        }
    6903
    
                                                    
                                                
    6904
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    6905
            bytes32 m0;
    6906
            bytes32 m1;
    6907
            bytes32 m2;
    6908
            bytes32 m3;
    6909
            bytes32 m4;
    6910
            /// @solidity memory-safe-assembly
    6911
            assembly {
    6912
                m0 := mload(0x00)
    6913
                m1 := mload(0x20)
    6914
                m2 := mload(0x40)
    6915
                m3 := mload(0x60)
    6916
                m4 := mload(0x80)
    6917
                // Selector of `log(bool,uint256,bool,address)`.
    6918
                mstore(0x00, 0x9acd3616)
    6919
                mstore(0x20, p0)
    6920
                mstore(0x40, p1)
    6921
                mstore(0x60, p2)
    6922
                mstore(0x80, p3)
    6923
            }
    6924
            _sendLogPayload(0x1c, 0x84);
    6925
            /// @solidity memory-safe-assembly
    6926
            assembly {
    6927
                mstore(0x00, m0)
    6928
                mstore(0x20, m1)
    6929
                mstore(0x40, m2)
    6930
                mstore(0x60, m3)
    6931
                mstore(0x80, m4)
    6932
            }
    6933
        }
    6934
    
                                                    
                                                
    6935
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    6936
            bytes32 m0;
    6937
            bytes32 m1;
    6938
            bytes32 m2;
    6939
            bytes32 m3;
    6940
            bytes32 m4;
    6941
            /// @solidity memory-safe-assembly
    6942
            assembly {
    6943
                m0 := mload(0x00)
    6944
                m1 := mload(0x20)
    6945
                m2 := mload(0x40)
    6946
                m3 := mload(0x60)
    6947
                m4 := mload(0x80)
    6948
                // Selector of `log(bool,uint256,bool,bool)`.
    6949
                mstore(0x00, 0xceb5f4d7)
    6950
                mstore(0x20, p0)
    6951
                mstore(0x40, p1)
    6952
                mstore(0x60, p2)
    6953
                mstore(0x80, p3)
    6954
            }
    6955
            _sendLogPayload(0x1c, 0x84);
    6956
            /// @solidity memory-safe-assembly
    6957
            assembly {
    6958
                mstore(0x00, m0)
    6959
                mstore(0x20, m1)
    6960
                mstore(0x40, m2)
    6961
                mstore(0x60, m3)
    6962
                mstore(0x80, m4)
    6963
            }
    6964
        }
    6965
    
                                                    
                                                
    6966
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    6967
            bytes32 m0;
    6968
            bytes32 m1;
    6969
            bytes32 m2;
    6970
            bytes32 m3;
    6971
            bytes32 m4;
    6972
            /// @solidity memory-safe-assembly
    6973
            assembly {
    6974
                m0 := mload(0x00)
    6975
                m1 := mload(0x20)
    6976
                m2 := mload(0x40)
    6977
                m3 := mload(0x60)
    6978
                m4 := mload(0x80)
    6979
                // Selector of `log(bool,uint256,bool,uint256)`.
    6980
                mstore(0x00, 0x7f9bbca2)
    6981
                mstore(0x20, p0)
    6982
                mstore(0x40, p1)
    6983
                mstore(0x60, p2)
    6984
                mstore(0x80, p3)
    6985
            }
    6986
            _sendLogPayload(0x1c, 0x84);
    6987
            /// @solidity memory-safe-assembly
    6988
            assembly {
    6989
                mstore(0x00, m0)
    6990
                mstore(0x20, m1)
    6991
                mstore(0x40, m2)
    6992
                mstore(0x60, m3)
    6993
                mstore(0x80, m4)
    6994
            }
    6995
        }
    6996
    
                                                    
                                                
    6997
        function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    6998
            bytes32 m0;
    6999
            bytes32 m1;
    7000
            bytes32 m2;
    7001
            bytes32 m3;
    7002
            bytes32 m4;
    7003
            bytes32 m5;
    7004
            bytes32 m6;
    7005
            /// @solidity memory-safe-assembly
    7006
            assembly {
    7007
                function writeString(pos, w) {
    7008
                    let length := 0
    7009
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7010
                    mstore(pos, length)
    7011
                    let shift := sub(256, shl(3, length))
    7012
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7013
                }
    7014
                m0 := mload(0x00)
    7015
                m1 := mload(0x20)
    7016
                m2 := mload(0x40)
    7017
                m3 := mload(0x60)
    7018
                m4 := mload(0x80)
    7019
                m5 := mload(0xa0)
    7020
                m6 := mload(0xc0)
    7021
                // Selector of `log(bool,uint256,bool,string)`.
    7022
                mstore(0x00, 0x9143dbb1)
    7023
                mstore(0x20, p0)
    7024
                mstore(0x40, p1)
    7025
                mstore(0x60, p2)
    7026
                mstore(0x80, 0x80)
    7027
                writeString(0xa0, p3)
    7028
            }
    7029
            _sendLogPayload(0x1c, 0xc4);
    7030
            /// @solidity memory-safe-assembly
    7031
            assembly {
    7032
                mstore(0x00, m0)
    7033
                mstore(0x20, m1)
    7034
                mstore(0x40, m2)
    7035
                mstore(0x60, m3)
    7036
                mstore(0x80, m4)
    7037
                mstore(0xa0, m5)
    7038
                mstore(0xc0, m6)
    7039
            }
    7040
        }
    7041
    
                                                    
                                                
    7042
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    7043
            bytes32 m0;
    7044
            bytes32 m1;
    7045
            bytes32 m2;
    7046
            bytes32 m3;
    7047
            bytes32 m4;
    7048
            /// @solidity memory-safe-assembly
    7049
            assembly {
    7050
                m0 := mload(0x00)
    7051
                m1 := mload(0x20)
    7052
                m2 := mload(0x40)
    7053
                m3 := mload(0x60)
    7054
                m4 := mload(0x80)
    7055
                // Selector of `log(bool,uint256,uint256,address)`.
    7056
                mstore(0x00, 0x00dd87b9)
    7057
                mstore(0x20, p0)
    7058
                mstore(0x40, p1)
    7059
                mstore(0x60, p2)
    7060
                mstore(0x80, p3)
    7061
            }
    7062
            _sendLogPayload(0x1c, 0x84);
    7063
            /// @solidity memory-safe-assembly
    7064
            assembly {
    7065
                mstore(0x00, m0)
    7066
                mstore(0x20, m1)
    7067
                mstore(0x40, m2)
    7068
                mstore(0x60, m3)
    7069
                mstore(0x80, m4)
    7070
            }
    7071
        }
    7072
    
                                                    
                                                
    7073
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    7074
            bytes32 m0;
    7075
            bytes32 m1;
    7076
            bytes32 m2;
    7077
            bytes32 m3;
    7078
            bytes32 m4;
    7079
            /// @solidity memory-safe-assembly
    7080
            assembly {
    7081
                m0 := mload(0x00)
    7082
                m1 := mload(0x20)
    7083
                m2 := mload(0x40)
    7084
                m3 := mload(0x60)
    7085
                m4 := mload(0x80)
    7086
                // Selector of `log(bool,uint256,uint256,bool)`.
    7087
                mstore(0x00, 0xbe984353)
    7088
                mstore(0x20, p0)
    7089
                mstore(0x40, p1)
    7090
                mstore(0x60, p2)
    7091
                mstore(0x80, p3)
    7092
            }
    7093
            _sendLogPayload(0x1c, 0x84);
    7094
            /// @solidity memory-safe-assembly
    7095
            assembly {
    7096
                mstore(0x00, m0)
    7097
                mstore(0x20, m1)
    7098
                mstore(0x40, m2)
    7099
                mstore(0x60, m3)
    7100
                mstore(0x80, m4)
    7101
            }
    7102
        }
    7103
    
                                                    
                                                
    7104
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    7105
            bytes32 m0;
    7106
            bytes32 m1;
    7107
            bytes32 m2;
    7108
            bytes32 m3;
    7109
            bytes32 m4;
    7110
            /// @solidity memory-safe-assembly
    7111
            assembly {
    7112
                m0 := mload(0x00)
    7113
                m1 := mload(0x20)
    7114
                m2 := mload(0x40)
    7115
                m3 := mload(0x60)
    7116
                m4 := mload(0x80)
    7117
                // Selector of `log(bool,uint256,uint256,uint256)`.
    7118
                mstore(0x00, 0x374bb4b2)
    7119
                mstore(0x20, p0)
    7120
                mstore(0x40, p1)
    7121
                mstore(0x60, p2)
    7122
                mstore(0x80, p3)
    7123
            }
    7124
            _sendLogPayload(0x1c, 0x84);
    7125
            /// @solidity memory-safe-assembly
    7126
            assembly {
    7127
                mstore(0x00, m0)
    7128
                mstore(0x20, m1)
    7129
                mstore(0x40, m2)
    7130
                mstore(0x60, m3)
    7131
                mstore(0x80, m4)
    7132
            }
    7133
        }
    7134
    
                                                    
                                                
    7135
        function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    7136
            bytes32 m0;
    7137
            bytes32 m1;
    7138
            bytes32 m2;
    7139
            bytes32 m3;
    7140
            bytes32 m4;
    7141
            bytes32 m5;
    7142
            bytes32 m6;
    7143
            /// @solidity memory-safe-assembly
    7144
            assembly {
    7145
                function writeString(pos, w) {
    7146
                    let length := 0
    7147
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7148
                    mstore(pos, length)
    7149
                    let shift := sub(256, shl(3, length))
    7150
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7151
                }
    7152
                m0 := mload(0x00)
    7153
                m1 := mload(0x20)
    7154
                m2 := mload(0x40)
    7155
                m3 := mload(0x60)
    7156
                m4 := mload(0x80)
    7157
                m5 := mload(0xa0)
    7158
                m6 := mload(0xc0)
    7159
                // Selector of `log(bool,uint256,uint256,string)`.
    7160
                mstore(0x00, 0x8e69fb5d)
    7161
                mstore(0x20, p0)
    7162
                mstore(0x40, p1)
    7163
                mstore(0x60, p2)
    7164
                mstore(0x80, 0x80)
    7165
                writeString(0xa0, p3)
    7166
            }
    7167
            _sendLogPayload(0x1c, 0xc4);
    7168
            /// @solidity memory-safe-assembly
    7169
            assembly {
    7170
                mstore(0x00, m0)
    7171
                mstore(0x20, m1)
    7172
                mstore(0x40, m2)
    7173
                mstore(0x60, m3)
    7174
                mstore(0x80, m4)
    7175
                mstore(0xa0, m5)
    7176
                mstore(0xc0, m6)
    7177
            }
    7178
        }
    7179
    
                                                    
                                                
    7180
        function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {
    7181
            bytes32 m0;
    7182
            bytes32 m1;
    7183
            bytes32 m2;
    7184
            bytes32 m3;
    7185
            bytes32 m4;
    7186
            bytes32 m5;
    7187
            bytes32 m6;
    7188
            /// @solidity memory-safe-assembly
    7189
            assembly {
    7190
                function writeString(pos, w) {
    7191
                    let length := 0
    7192
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7193
                    mstore(pos, length)
    7194
                    let shift := sub(256, shl(3, length))
    7195
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7196
                }
    7197
                m0 := mload(0x00)
    7198
                m1 := mload(0x20)
    7199
                m2 := mload(0x40)
    7200
                m3 := mload(0x60)
    7201
                m4 := mload(0x80)
    7202
                m5 := mload(0xa0)
    7203
                m6 := mload(0xc0)
    7204
                // Selector of `log(bool,uint256,string,address)`.
    7205
                mstore(0x00, 0xfedd1fff)
    7206
                mstore(0x20, p0)
    7207
                mstore(0x40, p1)
    7208
                mstore(0x60, 0x80)
    7209
                mstore(0x80, p3)
    7210
                writeString(0xa0, p2)
    7211
            }
    7212
            _sendLogPayload(0x1c, 0xc4);
    7213
            /// @solidity memory-safe-assembly
    7214
            assembly {
    7215
                mstore(0x00, m0)
    7216
                mstore(0x20, m1)
    7217
                mstore(0x40, m2)
    7218
                mstore(0x60, m3)
    7219
                mstore(0x80, m4)
    7220
                mstore(0xa0, m5)
    7221
                mstore(0xc0, m6)
    7222
            }
    7223
        }
    7224
    
                                                    
                                                
    7225
        function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    7226
            bytes32 m0;
    7227
            bytes32 m1;
    7228
            bytes32 m2;
    7229
            bytes32 m3;
    7230
            bytes32 m4;
    7231
            bytes32 m5;
    7232
            bytes32 m6;
    7233
            /// @solidity memory-safe-assembly
    7234
            assembly {
    7235
                function writeString(pos, w) {
    7236
                    let length := 0
    7237
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7238
                    mstore(pos, length)
    7239
                    let shift := sub(256, shl(3, length))
    7240
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7241
                }
    7242
                m0 := mload(0x00)
    7243
                m1 := mload(0x20)
    7244
                m2 := mload(0x40)
    7245
                m3 := mload(0x60)
    7246
                m4 := mload(0x80)
    7247
                m5 := mload(0xa0)
    7248
                m6 := mload(0xc0)
    7249
                // Selector of `log(bool,uint256,string,bool)`.
    7250
                mstore(0x00, 0xe5e70b2b)
    7251
                mstore(0x20, p0)
    7252
                mstore(0x40, p1)
    7253
                mstore(0x60, 0x80)
    7254
                mstore(0x80, p3)
    7255
                writeString(0xa0, p2)
    7256
            }
    7257
            _sendLogPayload(0x1c, 0xc4);
    7258
            /// @solidity memory-safe-assembly
    7259
            assembly {
    7260
                mstore(0x00, m0)
    7261
                mstore(0x20, m1)
    7262
                mstore(0x40, m2)
    7263
                mstore(0x60, m3)
    7264
                mstore(0x80, m4)
    7265
                mstore(0xa0, m5)
    7266
                mstore(0xc0, m6)
    7267
            }
    7268
        }
    7269
    
                                                    
                                                
    7270
        function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    7271
            bytes32 m0;
    7272
            bytes32 m1;
    7273
            bytes32 m2;
    7274
            bytes32 m3;
    7275
            bytes32 m4;
    7276
            bytes32 m5;
    7277
            bytes32 m6;
    7278
            /// @solidity memory-safe-assembly
    7279
            assembly {
    7280
                function writeString(pos, w) {
    7281
                    let length := 0
    7282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7283
                    mstore(pos, length)
    7284
                    let shift := sub(256, shl(3, length))
    7285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7286
                }
    7287
                m0 := mload(0x00)
    7288
                m1 := mload(0x20)
    7289
                m2 := mload(0x40)
    7290
                m3 := mload(0x60)
    7291
                m4 := mload(0x80)
    7292
                m5 := mload(0xa0)
    7293
                m6 := mload(0xc0)
    7294
                // Selector of `log(bool,uint256,string,uint256)`.
    7295
                mstore(0x00, 0x6a1199e2)
    7296
                mstore(0x20, p0)
    7297
                mstore(0x40, p1)
    7298
                mstore(0x60, 0x80)
    7299
                mstore(0x80, p3)
    7300
                writeString(0xa0, p2)
    7301
            }
    7302
            _sendLogPayload(0x1c, 0xc4);
    7303
            /// @solidity memory-safe-assembly
    7304
            assembly {
    7305
                mstore(0x00, m0)
    7306
                mstore(0x20, m1)
    7307
                mstore(0x40, m2)
    7308
                mstore(0x60, m3)
    7309
                mstore(0x80, m4)
    7310
                mstore(0xa0, m5)
    7311
                mstore(0xc0, m6)
    7312
            }
    7313
        }
    7314
    
                                                    
                                                
    7315
        function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    7316
            bytes32 m0;
    7317
            bytes32 m1;
    7318
            bytes32 m2;
    7319
            bytes32 m3;
    7320
            bytes32 m4;
    7321
            bytes32 m5;
    7322
            bytes32 m6;
    7323
            bytes32 m7;
    7324
            bytes32 m8;
    7325
            /// @solidity memory-safe-assembly
    7326
            assembly {
    7327
                function writeString(pos, w) {
    7328
                    let length := 0
    7329
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7330
                    mstore(pos, length)
    7331
                    let shift := sub(256, shl(3, length))
    7332
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7333
                }
    7334
                m0 := mload(0x00)
    7335
                m1 := mload(0x20)
    7336
                m2 := mload(0x40)
    7337
                m3 := mload(0x60)
    7338
                m4 := mload(0x80)
    7339
                m5 := mload(0xa0)
    7340
                m6 := mload(0xc0)
    7341
                m7 := mload(0xe0)
    7342
                m8 := mload(0x100)
    7343
                // Selector of `log(bool,uint256,string,string)`.
    7344
                mstore(0x00, 0xf5bc2249)
    7345
                mstore(0x20, p0)
    7346
                mstore(0x40, p1)
    7347
                mstore(0x60, 0x80)
    7348
                mstore(0x80, 0xc0)
    7349
                writeString(0xa0, p2)
    7350
                writeString(0xe0, p3)
    7351
            }
    7352
            _sendLogPayload(0x1c, 0x104);
    7353
            /// @solidity memory-safe-assembly
    7354
            assembly {
    7355
                mstore(0x00, m0)
    7356
                mstore(0x20, m1)
    7357
                mstore(0x40, m2)
    7358
                mstore(0x60, m3)
    7359
                mstore(0x80, m4)
    7360
                mstore(0xa0, m5)
    7361
                mstore(0xc0, m6)
    7362
                mstore(0xe0, m7)
    7363
                mstore(0x100, m8)
    7364
            }
    7365
        }
    7366
    
                                                    
                                                
    7367
        function log(bool p0, bytes32 p1, address p2, address p3) internal pure {
    7368
            bytes32 m0;
    7369
            bytes32 m1;
    7370
            bytes32 m2;
    7371
            bytes32 m3;
    7372
            bytes32 m4;
    7373
            bytes32 m5;
    7374
            bytes32 m6;
    7375
            /// @solidity memory-safe-assembly
    7376
            assembly {
    7377
                function writeString(pos, w) {
    7378
                    let length := 0
    7379
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7380
                    mstore(pos, length)
    7381
                    let shift := sub(256, shl(3, length))
    7382
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7383
                }
    7384
                m0 := mload(0x00)
    7385
                m1 := mload(0x20)
    7386
                m2 := mload(0x40)
    7387
                m3 := mload(0x60)
    7388
                m4 := mload(0x80)
    7389
                m5 := mload(0xa0)
    7390
                m6 := mload(0xc0)
    7391
                // Selector of `log(bool,string,address,address)`.
    7392
                mstore(0x00, 0x2b2b18dc)
    7393
                mstore(0x20, p0)
    7394
                mstore(0x40, 0x80)
    7395
                mstore(0x60, p2)
    7396
                mstore(0x80, p3)
    7397
                writeString(0xa0, p1)
    7398
            }
    7399
            _sendLogPayload(0x1c, 0xc4);
    7400
            /// @solidity memory-safe-assembly
    7401
            assembly {
    7402
                mstore(0x00, m0)
    7403
                mstore(0x20, m1)
    7404
                mstore(0x40, m2)
    7405
                mstore(0x60, m3)
    7406
                mstore(0x80, m4)
    7407
                mstore(0xa0, m5)
    7408
                mstore(0xc0, m6)
    7409
            }
    7410
        }
    7411
    
                                                    
                                                
    7412
        function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {
    7413
            bytes32 m0;
    7414
            bytes32 m1;
    7415
            bytes32 m2;
    7416
            bytes32 m3;
    7417
            bytes32 m4;
    7418
            bytes32 m5;
    7419
            bytes32 m6;
    7420
            /// @solidity memory-safe-assembly
    7421
            assembly {
    7422
                function writeString(pos, w) {
    7423
                    let length := 0
    7424
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7425
                    mstore(pos, length)
    7426
                    let shift := sub(256, shl(3, length))
    7427
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7428
                }
    7429
                m0 := mload(0x00)
    7430
                m1 := mload(0x20)
    7431
                m2 := mload(0x40)
    7432
                m3 := mload(0x60)
    7433
                m4 := mload(0x80)
    7434
                m5 := mload(0xa0)
    7435
                m6 := mload(0xc0)
    7436
                // Selector of `log(bool,string,address,bool)`.
    7437
                mstore(0x00, 0x6dd434ca)
    7438
                mstore(0x20, p0)
    7439
                mstore(0x40, 0x80)
    7440
                mstore(0x60, p2)
    7441
                mstore(0x80, p3)
    7442
                writeString(0xa0, p1)
    7443
            }
    7444
            _sendLogPayload(0x1c, 0xc4);
    7445
            /// @solidity memory-safe-assembly
    7446
            assembly {
    7447
                mstore(0x00, m0)
    7448
                mstore(0x20, m1)
    7449
                mstore(0x40, m2)
    7450
                mstore(0x60, m3)
    7451
                mstore(0x80, m4)
    7452
                mstore(0xa0, m5)
    7453
                mstore(0xc0, m6)
    7454
            }
    7455
        }
    7456
    
                                                    
                                                
    7457
        function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {
    7458
            bytes32 m0;
    7459
            bytes32 m1;
    7460
            bytes32 m2;
    7461
            bytes32 m3;
    7462
            bytes32 m4;
    7463
            bytes32 m5;
    7464
            bytes32 m6;
    7465
            /// @solidity memory-safe-assembly
    7466
            assembly {
    7467
                function writeString(pos, w) {
    7468
                    let length := 0
    7469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7470
                    mstore(pos, length)
    7471
                    let shift := sub(256, shl(3, length))
    7472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7473
                }
    7474
                m0 := mload(0x00)
    7475
                m1 := mload(0x20)
    7476
                m2 := mload(0x40)
    7477
                m3 := mload(0x60)
    7478
                m4 := mload(0x80)
    7479
                m5 := mload(0xa0)
    7480
                m6 := mload(0xc0)
    7481
                // Selector of `log(bool,string,address,uint256)`.
    7482
                mstore(0x00, 0xa5cada94)
    7483
                mstore(0x20, p0)
    7484
                mstore(0x40, 0x80)
    7485
                mstore(0x60, p2)
    7486
                mstore(0x80, p3)
    7487
                writeString(0xa0, p1)
    7488
            }
    7489
            _sendLogPayload(0x1c, 0xc4);
    7490
            /// @solidity memory-safe-assembly
    7491
            assembly {
    7492
                mstore(0x00, m0)
    7493
                mstore(0x20, m1)
    7494
                mstore(0x40, m2)
    7495
                mstore(0x60, m3)
    7496
                mstore(0x80, m4)
    7497
                mstore(0xa0, m5)
    7498
                mstore(0xc0, m6)
    7499
            }
    7500
        }
    7501
    
                                                    
                                                
    7502
        function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    7503
            bytes32 m0;
    7504
            bytes32 m1;
    7505
            bytes32 m2;
    7506
            bytes32 m3;
    7507
            bytes32 m4;
    7508
            bytes32 m5;
    7509
            bytes32 m6;
    7510
            bytes32 m7;
    7511
            bytes32 m8;
    7512
            /// @solidity memory-safe-assembly
    7513
            assembly {
    7514
                function writeString(pos, w) {
    7515
                    let length := 0
    7516
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7517
                    mstore(pos, length)
    7518
                    let shift := sub(256, shl(3, length))
    7519
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7520
                }
    7521
                m0 := mload(0x00)
    7522
                m1 := mload(0x20)
    7523
                m2 := mload(0x40)
    7524
                m3 := mload(0x60)
    7525
                m4 := mload(0x80)
    7526
                m5 := mload(0xa0)
    7527
                m6 := mload(0xc0)
    7528
                m7 := mload(0xe0)
    7529
                m8 := mload(0x100)
    7530
                // Selector of `log(bool,string,address,string)`.
    7531
                mstore(0x00, 0x12d6c788)
    7532
                mstore(0x20, p0)
    7533
                mstore(0x40, 0x80)
    7534
                mstore(0x60, p2)
    7535
                mstore(0x80, 0xc0)
    7536
                writeString(0xa0, p1)
    7537
                writeString(0xe0, p3)
    7538
            }
    7539
            _sendLogPayload(0x1c, 0x104);
    7540
            /// @solidity memory-safe-assembly
    7541
            assembly {
    7542
                mstore(0x00, m0)
    7543
                mstore(0x20, m1)
    7544
                mstore(0x40, m2)
    7545
                mstore(0x60, m3)
    7546
                mstore(0x80, m4)
    7547
                mstore(0xa0, m5)
    7548
                mstore(0xc0, m6)
    7549
                mstore(0xe0, m7)
    7550
                mstore(0x100, m8)
    7551
            }
    7552
        }
    7553
    
                                                    
                                                
    7554
        function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {
    7555
            bytes32 m0;
    7556
            bytes32 m1;
    7557
            bytes32 m2;
    7558
            bytes32 m3;
    7559
            bytes32 m4;
    7560
            bytes32 m5;
    7561
            bytes32 m6;
    7562
            /// @solidity memory-safe-assembly
    7563
            assembly {
    7564
                function writeString(pos, w) {
    7565
                    let length := 0
    7566
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7567
                    mstore(pos, length)
    7568
                    let shift := sub(256, shl(3, length))
    7569
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7570
                }
    7571
                m0 := mload(0x00)
    7572
                m1 := mload(0x20)
    7573
                m2 := mload(0x40)
    7574
                m3 := mload(0x60)
    7575
                m4 := mload(0x80)
    7576
                m5 := mload(0xa0)
    7577
                m6 := mload(0xc0)
    7578
                // Selector of `log(bool,string,bool,address)`.
    7579
                mstore(0x00, 0x538e06ab)
    7580
                mstore(0x20, p0)
    7581
                mstore(0x40, 0x80)
    7582
                mstore(0x60, p2)
    7583
                mstore(0x80, p3)
    7584
                writeString(0xa0, p1)
    7585
            }
    7586
            _sendLogPayload(0x1c, 0xc4);
    7587
            /// @solidity memory-safe-assembly
    7588
            assembly {
    7589
                mstore(0x00, m0)
    7590
                mstore(0x20, m1)
    7591
                mstore(0x40, m2)
    7592
                mstore(0x60, m3)
    7593
                mstore(0x80, m4)
    7594
                mstore(0xa0, m5)
    7595
                mstore(0xc0, m6)
    7596
            }
    7597
        }
    7598
    
                                                    
                                                
    7599
        function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {
    7600
            bytes32 m0;
    7601
            bytes32 m1;
    7602
            bytes32 m2;
    7603
            bytes32 m3;
    7604
            bytes32 m4;
    7605
            bytes32 m5;
    7606
            bytes32 m6;
    7607
            /// @solidity memory-safe-assembly
    7608
            assembly {
    7609
                function writeString(pos, w) {
    7610
                    let length := 0
    7611
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7612
                    mstore(pos, length)
    7613
                    let shift := sub(256, shl(3, length))
    7614
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7615
                }
    7616
                m0 := mload(0x00)
    7617
                m1 := mload(0x20)
    7618
                m2 := mload(0x40)
    7619
                m3 := mload(0x60)
    7620
                m4 := mload(0x80)
    7621
                m5 := mload(0xa0)
    7622
                m6 := mload(0xc0)
    7623
                // Selector of `log(bool,string,bool,bool)`.
    7624
                mstore(0x00, 0xdc5e935b)
    7625
                mstore(0x20, p0)
    7626
                mstore(0x40, 0x80)
    7627
                mstore(0x60, p2)
    7628
                mstore(0x80, p3)
    7629
                writeString(0xa0, p1)
    7630
            }
    7631
            _sendLogPayload(0x1c, 0xc4);
    7632
            /// @solidity memory-safe-assembly
    7633
            assembly {
    7634
                mstore(0x00, m0)
    7635
                mstore(0x20, m1)
    7636
                mstore(0x40, m2)
    7637
                mstore(0x60, m3)
    7638
                mstore(0x80, m4)
    7639
                mstore(0xa0, m5)
    7640
                mstore(0xc0, m6)
    7641
            }
    7642
        }
    7643
    
                                                    
                                                
    7644
        function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    7645
            bytes32 m0;
    7646
            bytes32 m1;
    7647
            bytes32 m2;
    7648
            bytes32 m3;
    7649
            bytes32 m4;
    7650
            bytes32 m5;
    7651
            bytes32 m6;
    7652
            /// @solidity memory-safe-assembly
    7653
            assembly {
    7654
                function writeString(pos, w) {
    7655
                    let length := 0
    7656
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7657
                    mstore(pos, length)
    7658
                    let shift := sub(256, shl(3, length))
    7659
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7660
                }
    7661
                m0 := mload(0x00)
    7662
                m1 := mload(0x20)
    7663
                m2 := mload(0x40)
    7664
                m3 := mload(0x60)
    7665
                m4 := mload(0x80)
    7666
                m5 := mload(0xa0)
    7667
                m6 := mload(0xc0)
    7668
                // Selector of `log(bool,string,bool,uint256)`.
    7669
                mstore(0x00, 0x1606a393)
    7670
                mstore(0x20, p0)
    7671
                mstore(0x40, 0x80)
    7672
                mstore(0x60, p2)
    7673
                mstore(0x80, p3)
    7674
                writeString(0xa0, p1)
    7675
            }
    7676
            _sendLogPayload(0x1c, 0xc4);
    7677
            /// @solidity memory-safe-assembly
    7678
            assembly {
    7679
                mstore(0x00, m0)
    7680
                mstore(0x20, m1)
    7681
                mstore(0x40, m2)
    7682
                mstore(0x60, m3)
    7683
                mstore(0x80, m4)
    7684
                mstore(0xa0, m5)
    7685
                mstore(0xc0, m6)
    7686
            }
    7687
        }
    7688
    
                                                    
                                                
    7689
        function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    7690
            bytes32 m0;
    7691
            bytes32 m1;
    7692
            bytes32 m2;
    7693
            bytes32 m3;
    7694
            bytes32 m4;
    7695
            bytes32 m5;
    7696
            bytes32 m6;
    7697
            bytes32 m7;
    7698
            bytes32 m8;
    7699
            /// @solidity memory-safe-assembly
    7700
            assembly {
    7701
                function writeString(pos, w) {
    7702
                    let length := 0
    7703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7704
                    mstore(pos, length)
    7705
                    let shift := sub(256, shl(3, length))
    7706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7707
                }
    7708
                m0 := mload(0x00)
    7709
                m1 := mload(0x20)
    7710
                m2 := mload(0x40)
    7711
                m3 := mload(0x60)
    7712
                m4 := mload(0x80)
    7713
                m5 := mload(0xa0)
    7714
                m6 := mload(0xc0)
    7715
                m7 := mload(0xe0)
    7716
                m8 := mload(0x100)
    7717
                // Selector of `log(bool,string,bool,string)`.
    7718
                mstore(0x00, 0x483d0416)
    7719
                mstore(0x20, p0)
    7720
                mstore(0x40, 0x80)
    7721
                mstore(0x60, p2)
    7722
                mstore(0x80, 0xc0)
    7723
                writeString(0xa0, p1)
    7724
                writeString(0xe0, p3)
    7725
            }
    7726
            _sendLogPayload(0x1c, 0x104);
    7727
            /// @solidity memory-safe-assembly
    7728
            assembly {
    7729
                mstore(0x00, m0)
    7730
                mstore(0x20, m1)
    7731
                mstore(0x40, m2)
    7732
                mstore(0x60, m3)
    7733
                mstore(0x80, m4)
    7734
                mstore(0xa0, m5)
    7735
                mstore(0xc0, m6)
    7736
                mstore(0xe0, m7)
    7737
                mstore(0x100, m8)
    7738
            }
    7739
        }
    7740
    
                                                    
                                                
    7741
        function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {
    7742
            bytes32 m0;
    7743
            bytes32 m1;
    7744
            bytes32 m2;
    7745
            bytes32 m3;
    7746
            bytes32 m4;
    7747
            bytes32 m5;
    7748
            bytes32 m6;
    7749
            /// @solidity memory-safe-assembly
    7750
            assembly {
    7751
                function writeString(pos, w) {
    7752
                    let length := 0
    7753
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7754
                    mstore(pos, length)
    7755
                    let shift := sub(256, shl(3, length))
    7756
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7757
                }
    7758
                m0 := mload(0x00)
    7759
                m1 := mload(0x20)
    7760
                m2 := mload(0x40)
    7761
                m3 := mload(0x60)
    7762
                m4 := mload(0x80)
    7763
                m5 := mload(0xa0)
    7764
                m6 := mload(0xc0)
    7765
                // Selector of `log(bool,string,uint256,address)`.
    7766
                mstore(0x00, 0x1596a1ce)
    7767
                mstore(0x20, p0)
    7768
                mstore(0x40, 0x80)
    7769
                mstore(0x60, p2)
    7770
                mstore(0x80, p3)
    7771
                writeString(0xa0, p1)
    7772
            }
    7773
            _sendLogPayload(0x1c, 0xc4);
    7774
            /// @solidity memory-safe-assembly
    7775
            assembly {
    7776
                mstore(0x00, m0)
    7777
                mstore(0x20, m1)
    7778
                mstore(0x40, m2)
    7779
                mstore(0x60, m3)
    7780
                mstore(0x80, m4)
    7781
                mstore(0xa0, m5)
    7782
                mstore(0xc0, m6)
    7783
            }
    7784
        }
    7785
    
                                                    
                                                
    7786
        function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    7787
            bytes32 m0;
    7788
            bytes32 m1;
    7789
            bytes32 m2;
    7790
            bytes32 m3;
    7791
            bytes32 m4;
    7792
            bytes32 m5;
    7793
            bytes32 m6;
    7794
            /// @solidity memory-safe-assembly
    7795
            assembly {
    7796
                function writeString(pos, w) {
    7797
                    let length := 0
    7798
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7799
                    mstore(pos, length)
    7800
                    let shift := sub(256, shl(3, length))
    7801
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7802
                }
    7803
                m0 := mload(0x00)
    7804
                m1 := mload(0x20)
    7805
                m2 := mload(0x40)
    7806
                m3 := mload(0x60)
    7807
                m4 := mload(0x80)
    7808
                m5 := mload(0xa0)
    7809
                m6 := mload(0xc0)
    7810
                // Selector of `log(bool,string,uint256,bool)`.
    7811
                mstore(0x00, 0x6b0e5d53)
    7812
                mstore(0x20, p0)
    7813
                mstore(0x40, 0x80)
    7814
                mstore(0x60, p2)
    7815
                mstore(0x80, p3)
    7816
                writeString(0xa0, p1)
    7817
            }
    7818
            _sendLogPayload(0x1c, 0xc4);
    7819
            /// @solidity memory-safe-assembly
    7820
            assembly {
    7821
                mstore(0x00, m0)
    7822
                mstore(0x20, m1)
    7823
                mstore(0x40, m2)
    7824
                mstore(0x60, m3)
    7825
                mstore(0x80, m4)
    7826
                mstore(0xa0, m5)
    7827
                mstore(0xc0, m6)
    7828
            }
    7829
        }
    7830
    
                                                    
                                                
    7831
        function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    7832
            bytes32 m0;
    7833
            bytes32 m1;
    7834
            bytes32 m2;
    7835
            bytes32 m3;
    7836
            bytes32 m4;
    7837
            bytes32 m5;
    7838
            bytes32 m6;
    7839
            /// @solidity memory-safe-assembly
    7840
            assembly {
    7841
                function writeString(pos, w) {
    7842
                    let length := 0
    7843
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7844
                    mstore(pos, length)
    7845
                    let shift := sub(256, shl(3, length))
    7846
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7847
                }
    7848
                m0 := mload(0x00)
    7849
                m1 := mload(0x20)
    7850
                m2 := mload(0x40)
    7851
                m3 := mload(0x60)
    7852
                m4 := mload(0x80)
    7853
                m5 := mload(0xa0)
    7854
                m6 := mload(0xc0)
    7855
                // Selector of `log(bool,string,uint256,uint256)`.
    7856
                mstore(0x00, 0x28863fcb)
    7857
                mstore(0x20, p0)
    7858
                mstore(0x40, 0x80)
    7859
                mstore(0x60, p2)
    7860
                mstore(0x80, p3)
    7861
                writeString(0xa0, p1)
    7862
            }
    7863
            _sendLogPayload(0x1c, 0xc4);
    7864
            /// @solidity memory-safe-assembly
    7865
            assembly {
    7866
                mstore(0x00, m0)
    7867
                mstore(0x20, m1)
    7868
                mstore(0x40, m2)
    7869
                mstore(0x60, m3)
    7870
                mstore(0x80, m4)
    7871
                mstore(0xa0, m5)
    7872
                mstore(0xc0, m6)
    7873
            }
    7874
        }
    7875
    
                                                    
                                                
    7876
        function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    7877
            bytes32 m0;
    7878
            bytes32 m1;
    7879
            bytes32 m2;
    7880
            bytes32 m3;
    7881
            bytes32 m4;
    7882
            bytes32 m5;
    7883
            bytes32 m6;
    7884
            bytes32 m7;
    7885
            bytes32 m8;
    7886
            /// @solidity memory-safe-assembly
    7887
            assembly {
    7888
                function writeString(pos, w) {
    7889
                    let length := 0
    7890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7891
                    mstore(pos, length)
    7892
                    let shift := sub(256, shl(3, length))
    7893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7894
                }
    7895
                m0 := mload(0x00)
    7896
                m1 := mload(0x20)
    7897
                m2 := mload(0x40)
    7898
                m3 := mload(0x60)
    7899
                m4 := mload(0x80)
    7900
                m5 := mload(0xa0)
    7901
                m6 := mload(0xc0)
    7902
                m7 := mload(0xe0)
    7903
                m8 := mload(0x100)
    7904
                // Selector of `log(bool,string,uint256,string)`.
    7905
                mstore(0x00, 0x1ad96de6)
    7906
                mstore(0x20, p0)
    7907
                mstore(0x40, 0x80)
    7908
                mstore(0x60, p2)
    7909
                mstore(0x80, 0xc0)
    7910
                writeString(0xa0, p1)
    7911
                writeString(0xe0, p3)
    7912
            }
    7913
            _sendLogPayload(0x1c, 0x104);
    7914
            /// @solidity memory-safe-assembly
    7915
            assembly {
    7916
                mstore(0x00, m0)
    7917
                mstore(0x20, m1)
    7918
                mstore(0x40, m2)
    7919
                mstore(0x60, m3)
    7920
                mstore(0x80, m4)
    7921
                mstore(0xa0, m5)
    7922
                mstore(0xc0, m6)
    7923
                mstore(0xe0, m7)
    7924
                mstore(0x100, m8)
    7925
            }
    7926
        }
    7927
    
                                                    
                                                
    7928
        function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    7929
            bytes32 m0;
    7930
            bytes32 m1;
    7931
            bytes32 m2;
    7932
            bytes32 m3;
    7933
            bytes32 m4;
    7934
            bytes32 m5;
    7935
            bytes32 m6;
    7936
            bytes32 m7;
    7937
            bytes32 m8;
    7938
            /// @solidity memory-safe-assembly
    7939
            assembly {
    7940
                function writeString(pos, w) {
    7941
                    let length := 0
    7942
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7943
                    mstore(pos, length)
    7944
                    let shift := sub(256, shl(3, length))
    7945
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7946
                }
    7947
                m0 := mload(0x00)
    7948
                m1 := mload(0x20)
    7949
                m2 := mload(0x40)
    7950
                m3 := mload(0x60)
    7951
                m4 := mload(0x80)
    7952
                m5 := mload(0xa0)
    7953
                m6 := mload(0xc0)
    7954
                m7 := mload(0xe0)
    7955
                m8 := mload(0x100)
    7956
                // Selector of `log(bool,string,string,address)`.
    7957
                mstore(0x00, 0x97d394d8)
    7958
                mstore(0x20, p0)
    7959
                mstore(0x40, 0x80)
    7960
                mstore(0x60, 0xc0)
    7961
                mstore(0x80, p3)
    7962
                writeString(0xa0, p1)
    7963
                writeString(0xe0, p2)
    7964
            }
    7965
            _sendLogPayload(0x1c, 0x104);
    7966
            /// @solidity memory-safe-assembly
    7967
            assembly {
    7968
                mstore(0x00, m0)
    7969
                mstore(0x20, m1)
    7970
                mstore(0x40, m2)
    7971
                mstore(0x60, m3)
    7972
                mstore(0x80, m4)
    7973
                mstore(0xa0, m5)
    7974
                mstore(0xc0, m6)
    7975
                mstore(0xe0, m7)
    7976
                mstore(0x100, m8)
    7977
            }
    7978
        }
    7979
    
                                                    
                                                
    7980
        function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    7981
            bytes32 m0;
    7982
            bytes32 m1;
    7983
            bytes32 m2;
    7984
            bytes32 m3;
    7985
            bytes32 m4;
    7986
            bytes32 m5;
    7987
            bytes32 m6;
    7988
            bytes32 m7;
    7989
            bytes32 m8;
    7990
            /// @solidity memory-safe-assembly
    7991
            assembly {
    7992
                function writeString(pos, w) {
    7993
                    let length := 0
    7994
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7995
                    mstore(pos, length)
    7996
                    let shift := sub(256, shl(3, length))
    7997
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7998
                }
    7999
                m0 := mload(0x00)
    8000
                m1 := mload(0x20)
    8001
                m2 := mload(0x40)
    8002
                m3 := mload(0x60)
    8003
                m4 := mload(0x80)
    8004
                m5 := mload(0xa0)
    8005
                m6 := mload(0xc0)
    8006
                m7 := mload(0xe0)
    8007
                m8 := mload(0x100)
    8008
                // Selector of `log(bool,string,string,bool)`.
    8009
                mstore(0x00, 0x1e4b87e5)
    8010
                mstore(0x20, p0)
    8011
                mstore(0x40, 0x80)
    8012
                mstore(0x60, 0xc0)
    8013
                mstore(0x80, p3)
    8014
                writeString(0xa0, p1)
    8015
                writeString(0xe0, p2)
    8016
            }
    8017
            _sendLogPayload(0x1c, 0x104);
    8018
            /// @solidity memory-safe-assembly
    8019
            assembly {
    8020
                mstore(0x00, m0)
    8021
                mstore(0x20, m1)
    8022
                mstore(0x40, m2)
    8023
                mstore(0x60, m3)
    8024
                mstore(0x80, m4)
    8025
                mstore(0xa0, m5)
    8026
                mstore(0xc0, m6)
    8027
                mstore(0xe0, m7)
    8028
                mstore(0x100, m8)
    8029
            }
    8030
        }
    8031
    
                                                    
                                                
    8032
        function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    8033
            bytes32 m0;
    8034
            bytes32 m1;
    8035
            bytes32 m2;
    8036
            bytes32 m3;
    8037
            bytes32 m4;
    8038
            bytes32 m5;
    8039
            bytes32 m6;
    8040
            bytes32 m7;
    8041
            bytes32 m8;
    8042
            /// @solidity memory-safe-assembly
    8043
            assembly {
    8044
                function writeString(pos, w) {
    8045
                    let length := 0
    8046
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8047
                    mstore(pos, length)
    8048
                    let shift := sub(256, shl(3, length))
    8049
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8050
                }
    8051
                m0 := mload(0x00)
    8052
                m1 := mload(0x20)
    8053
                m2 := mload(0x40)
    8054
                m3 := mload(0x60)
    8055
                m4 := mload(0x80)
    8056
                m5 := mload(0xa0)
    8057
                m6 := mload(0xc0)
    8058
                m7 := mload(0xe0)
    8059
                m8 := mload(0x100)
    8060
                // Selector of `log(bool,string,string,uint256)`.
    8061
                mstore(0x00, 0x7be0c3eb)
    8062
                mstore(0x20, p0)
    8063
                mstore(0x40, 0x80)
    8064
                mstore(0x60, 0xc0)
    8065
                mstore(0x80, p3)
    8066
                writeString(0xa0, p1)
    8067
                writeString(0xe0, p2)
    8068
            }
    8069
            _sendLogPayload(0x1c, 0x104);
    8070
            /// @solidity memory-safe-assembly
    8071
            assembly {
    8072
                mstore(0x00, m0)
    8073
                mstore(0x20, m1)
    8074
                mstore(0x40, m2)
    8075
                mstore(0x60, m3)
    8076
                mstore(0x80, m4)
    8077
                mstore(0xa0, m5)
    8078
                mstore(0xc0, m6)
    8079
                mstore(0xe0, m7)
    8080
                mstore(0x100, m8)
    8081
            }
    8082
        }
    8083
    
                                                    
                                                
    8084
        function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    8085
            bytes32 m0;
    8086
            bytes32 m1;
    8087
            bytes32 m2;
    8088
            bytes32 m3;
    8089
            bytes32 m4;
    8090
            bytes32 m5;
    8091
            bytes32 m6;
    8092
            bytes32 m7;
    8093
            bytes32 m8;
    8094
            bytes32 m9;
    8095
            bytes32 m10;
    8096
            /// @solidity memory-safe-assembly
    8097
            assembly {
    8098
                function writeString(pos, w) {
    8099
                    let length := 0
    8100
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8101
                    mstore(pos, length)
    8102
                    let shift := sub(256, shl(3, length))
    8103
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8104
                }
    8105
                m0 := mload(0x00)
    8106
                m1 := mload(0x20)
    8107
                m2 := mload(0x40)
    8108
                m3 := mload(0x60)
    8109
                m4 := mload(0x80)
    8110
                m5 := mload(0xa0)
    8111
                m6 := mload(0xc0)
    8112
                m7 := mload(0xe0)
    8113
                m8 := mload(0x100)
    8114
                m9 := mload(0x120)
    8115
                m10 := mload(0x140)
    8116
                // Selector of `log(bool,string,string,string)`.
    8117
                mstore(0x00, 0x1762e32a)
    8118
                mstore(0x20, p0)
    8119
                mstore(0x40, 0x80)
    8120
                mstore(0x60, 0xc0)
    8121
                mstore(0x80, 0x100)
    8122
                writeString(0xa0, p1)
    8123
                writeString(0xe0, p2)
    8124
                writeString(0x120, p3)
    8125
            }
    8126
            _sendLogPayload(0x1c, 0x144);
    8127
            /// @solidity memory-safe-assembly
    8128
            assembly {
    8129
                mstore(0x00, m0)
    8130
                mstore(0x20, m1)
    8131
                mstore(0x40, m2)
    8132
                mstore(0x60, m3)
    8133
                mstore(0x80, m4)
    8134
                mstore(0xa0, m5)
    8135
                mstore(0xc0, m6)
    8136
                mstore(0xe0, m7)
    8137
                mstore(0x100, m8)
    8138
                mstore(0x120, m9)
    8139
                mstore(0x140, m10)
    8140
            }
    8141
        }
    8142
    
                                                    
                                                
    8143
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    8144
            bytes32 m0;
    8145
            bytes32 m1;
    8146
            bytes32 m2;
    8147
            bytes32 m3;
    8148
            bytes32 m4;
    8149
            /// @solidity memory-safe-assembly
    8150
            assembly {
    8151
                m0 := mload(0x00)
    8152
                m1 := mload(0x20)
    8153
                m2 := mload(0x40)
    8154
                m3 := mload(0x60)
    8155
                m4 := mload(0x80)
    8156
                // Selector of `log(uint256,address,address,address)`.
    8157
                mstore(0x00, 0x2488b414)
    8158
                mstore(0x20, p0)
    8159
                mstore(0x40, p1)
    8160
                mstore(0x60, p2)
    8161
                mstore(0x80, p3)
    8162
            }
    8163
            _sendLogPayload(0x1c, 0x84);
    8164
            /// @solidity memory-safe-assembly
    8165
            assembly {
    8166
                mstore(0x00, m0)
    8167
                mstore(0x20, m1)
    8168
                mstore(0x40, m2)
    8169
                mstore(0x60, m3)
    8170
                mstore(0x80, m4)
    8171
            }
    8172
        }
    8173
    
                                                    
                                                
    8174
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    8175
            bytes32 m0;
    8176
            bytes32 m1;
    8177
            bytes32 m2;
    8178
            bytes32 m3;
    8179
            bytes32 m4;
    8180
            /// @solidity memory-safe-assembly
    8181
            assembly {
    8182
                m0 := mload(0x00)
    8183
                m1 := mload(0x20)
    8184
                m2 := mload(0x40)
    8185
                m3 := mload(0x60)
    8186
                m4 := mload(0x80)
    8187
                // Selector of `log(uint256,address,address,bool)`.
    8188
                mstore(0x00, 0x091ffaf5)
    8189
                mstore(0x20, p0)
    8190
                mstore(0x40, p1)
    8191
                mstore(0x60, p2)
    8192
                mstore(0x80, p3)
    8193
            }
    8194
            _sendLogPayload(0x1c, 0x84);
    8195
            /// @solidity memory-safe-assembly
    8196
            assembly {
    8197
                mstore(0x00, m0)
    8198
                mstore(0x20, m1)
    8199
                mstore(0x40, m2)
    8200
                mstore(0x60, m3)
    8201
                mstore(0x80, m4)
    8202
            }
    8203
        }
    8204
    
                                                    
                                                
    8205
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    8206
            bytes32 m0;
    8207
            bytes32 m1;
    8208
            bytes32 m2;
    8209
            bytes32 m3;
    8210
            bytes32 m4;
    8211
            /// @solidity memory-safe-assembly
    8212
            assembly {
    8213
                m0 := mload(0x00)
    8214
                m1 := mload(0x20)
    8215
                m2 := mload(0x40)
    8216
                m3 := mload(0x60)
    8217
                m4 := mload(0x80)
    8218
                // Selector of `log(uint256,address,address,uint256)`.
    8219
                mstore(0x00, 0x736efbb6)
    8220
                mstore(0x20, p0)
    8221
                mstore(0x40, p1)
    8222
                mstore(0x60, p2)
    8223
                mstore(0x80, p3)
    8224
            }
    8225
            _sendLogPayload(0x1c, 0x84);
    8226
            /// @solidity memory-safe-assembly
    8227
            assembly {
    8228
                mstore(0x00, m0)
    8229
                mstore(0x20, m1)
    8230
                mstore(0x40, m2)
    8231
                mstore(0x60, m3)
    8232
                mstore(0x80, m4)
    8233
            }
    8234
        }
    8235
    
                                                    
                                                
    8236
        function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {
    8237
            bytes32 m0;
    8238
            bytes32 m1;
    8239
            bytes32 m2;
    8240
            bytes32 m3;
    8241
            bytes32 m4;
    8242
            bytes32 m5;
    8243
            bytes32 m6;
    8244
            /// @solidity memory-safe-assembly
    8245
            assembly {
    8246
                function writeString(pos, w) {
    8247
                    let length := 0
    8248
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8249
                    mstore(pos, length)
    8250
                    let shift := sub(256, shl(3, length))
    8251
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8252
                }
    8253
                m0 := mload(0x00)
    8254
                m1 := mload(0x20)
    8255
                m2 := mload(0x40)
    8256
                m3 := mload(0x60)
    8257
                m4 := mload(0x80)
    8258
                m5 := mload(0xa0)
    8259
                m6 := mload(0xc0)
    8260
                // Selector of `log(uint256,address,address,string)`.
    8261
                mstore(0x00, 0x031c6f73)
    8262
                mstore(0x20, p0)
    8263
                mstore(0x40, p1)
    8264
                mstore(0x60, p2)
    8265
                mstore(0x80, 0x80)
    8266
                writeString(0xa0, p3)
    8267
            }
    8268
            _sendLogPayload(0x1c, 0xc4);
    8269
            /// @solidity memory-safe-assembly
    8270
            assembly {
    8271
                mstore(0x00, m0)
    8272
                mstore(0x20, m1)
    8273
                mstore(0x40, m2)
    8274
                mstore(0x60, m3)
    8275
                mstore(0x80, m4)
    8276
                mstore(0xa0, m5)
    8277
                mstore(0xc0, m6)
    8278
            }
    8279
        }
    8280
    
                                                    
                                                
    8281
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    8282
            bytes32 m0;
    8283
            bytes32 m1;
    8284
            bytes32 m2;
    8285
            bytes32 m3;
    8286
            bytes32 m4;
    8287
            /// @solidity memory-safe-assembly
    8288
            assembly {
    8289
                m0 := mload(0x00)
    8290
                m1 := mload(0x20)
    8291
                m2 := mload(0x40)
    8292
                m3 := mload(0x60)
    8293
                m4 := mload(0x80)
    8294
                // Selector of `log(uint256,address,bool,address)`.
    8295
                mstore(0x00, 0xef72c513)
    8296
                mstore(0x20, p0)
    8297
                mstore(0x40, p1)
    8298
                mstore(0x60, p2)
    8299
                mstore(0x80, p3)
    8300
            }
    8301
            _sendLogPayload(0x1c, 0x84);
    8302
            /// @solidity memory-safe-assembly
    8303
            assembly {
    8304
                mstore(0x00, m0)
    8305
                mstore(0x20, m1)
    8306
                mstore(0x40, m2)
    8307
                mstore(0x60, m3)
    8308
                mstore(0x80, m4)
    8309
            }
    8310
        }
    8311
    
                                                    
                                                
    8312
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    8313
            bytes32 m0;
    8314
            bytes32 m1;
    8315
            bytes32 m2;
    8316
            bytes32 m3;
    8317
            bytes32 m4;
    8318
            /// @solidity memory-safe-assembly
    8319
            assembly {
    8320
                m0 := mload(0x00)
    8321
                m1 := mload(0x20)
    8322
                m2 := mload(0x40)
    8323
                m3 := mload(0x60)
    8324
                m4 := mload(0x80)
    8325
                // Selector of `log(uint256,address,bool,bool)`.
    8326
                mstore(0x00, 0xe351140f)
    8327
                mstore(0x20, p0)
    8328
                mstore(0x40, p1)
    8329
                mstore(0x60, p2)
    8330
                mstore(0x80, p3)
    8331
            }
    8332
            _sendLogPayload(0x1c, 0x84);
    8333
            /// @solidity memory-safe-assembly
    8334
            assembly {
    8335
                mstore(0x00, m0)
    8336
                mstore(0x20, m1)
    8337
                mstore(0x40, m2)
    8338
                mstore(0x60, m3)
    8339
                mstore(0x80, m4)
    8340
            }
    8341
        }
    8342
    
                                                    
                                                
    8343
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    8344
            bytes32 m0;
    8345
            bytes32 m1;
    8346
            bytes32 m2;
    8347
            bytes32 m3;
    8348
            bytes32 m4;
    8349
            /// @solidity memory-safe-assembly
    8350
            assembly {
    8351
                m0 := mload(0x00)
    8352
                m1 := mload(0x20)
    8353
                m2 := mload(0x40)
    8354
                m3 := mload(0x60)
    8355
                m4 := mload(0x80)
    8356
                // Selector of `log(uint256,address,bool,uint256)`.
    8357
                mstore(0x00, 0x5abd992a)
    8358
                mstore(0x20, p0)
    8359
                mstore(0x40, p1)
    8360
                mstore(0x60, p2)
    8361
                mstore(0x80, p3)
    8362
            }
    8363
            _sendLogPayload(0x1c, 0x84);
    8364
            /// @solidity memory-safe-assembly
    8365
            assembly {
    8366
                mstore(0x00, m0)
    8367
                mstore(0x20, m1)
    8368
                mstore(0x40, m2)
    8369
                mstore(0x60, m3)
    8370
                mstore(0x80, m4)
    8371
            }
    8372
        }
    8373
    
                                                    
                                                
    8374
        function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {
    8375
            bytes32 m0;
    8376
            bytes32 m1;
    8377
            bytes32 m2;
    8378
            bytes32 m3;
    8379
            bytes32 m4;
    8380
            bytes32 m5;
    8381
            bytes32 m6;
    8382
            /// @solidity memory-safe-assembly
    8383
            assembly {
    8384
                function writeString(pos, w) {
    8385
                    let length := 0
    8386
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8387
                    mstore(pos, length)
    8388
                    let shift := sub(256, shl(3, length))
    8389
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8390
                }
    8391
                m0 := mload(0x00)
    8392
                m1 := mload(0x20)
    8393
                m2 := mload(0x40)
    8394
                m3 := mload(0x60)
    8395
                m4 := mload(0x80)
    8396
                m5 := mload(0xa0)
    8397
                m6 := mload(0xc0)
    8398
                // Selector of `log(uint256,address,bool,string)`.
    8399
                mstore(0x00, 0x90fb06aa)
    8400
                mstore(0x20, p0)
    8401
                mstore(0x40, p1)
    8402
                mstore(0x60, p2)
    8403
                mstore(0x80, 0x80)
    8404
                writeString(0xa0, p3)
    8405
            }
    8406
            _sendLogPayload(0x1c, 0xc4);
    8407
            /// @solidity memory-safe-assembly
    8408
            assembly {
    8409
                mstore(0x00, m0)
    8410
                mstore(0x20, m1)
    8411
                mstore(0x40, m2)
    8412
                mstore(0x60, m3)
    8413
                mstore(0x80, m4)
    8414
                mstore(0xa0, m5)
    8415
                mstore(0xc0, m6)
    8416
            }
    8417
        }
    8418
    
                                                    
                                                
    8419
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    8420
            bytes32 m0;
    8421
            bytes32 m1;
    8422
            bytes32 m2;
    8423
            bytes32 m3;
    8424
            bytes32 m4;
    8425
            /// @solidity memory-safe-assembly
    8426
            assembly {
    8427
                m0 := mload(0x00)
    8428
                m1 := mload(0x20)
    8429
                m2 := mload(0x40)
    8430
                m3 := mload(0x60)
    8431
                m4 := mload(0x80)
    8432
                // Selector of `log(uint256,address,uint256,address)`.
    8433
                mstore(0x00, 0x15c127b5)
    8434
                mstore(0x20, p0)
    8435
                mstore(0x40, p1)
    8436
                mstore(0x60, p2)
    8437
                mstore(0x80, p3)
    8438
            }
    8439
            _sendLogPayload(0x1c, 0x84);
    8440
            /// @solidity memory-safe-assembly
    8441
            assembly {
    8442
                mstore(0x00, m0)
    8443
                mstore(0x20, m1)
    8444
                mstore(0x40, m2)
    8445
                mstore(0x60, m3)
    8446
                mstore(0x80, m4)
    8447
            }
    8448
        }
    8449
    
                                                    
                                                
    8450
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    8451
            bytes32 m0;
    8452
            bytes32 m1;
    8453
            bytes32 m2;
    8454
            bytes32 m3;
    8455
            bytes32 m4;
    8456
            /// @solidity memory-safe-assembly
    8457
            assembly {
    8458
                m0 := mload(0x00)
    8459
                m1 := mload(0x20)
    8460
                m2 := mload(0x40)
    8461
                m3 := mload(0x60)
    8462
                m4 := mload(0x80)
    8463
                // Selector of `log(uint256,address,uint256,bool)`.
    8464
                mstore(0x00, 0x5f743a7c)
    8465
                mstore(0x20, p0)
    8466
                mstore(0x40, p1)
    8467
                mstore(0x60, p2)
    8468
                mstore(0x80, p3)
    8469
            }
    8470
            _sendLogPayload(0x1c, 0x84);
    8471
            /// @solidity memory-safe-assembly
    8472
            assembly {
    8473
                mstore(0x00, m0)
    8474
                mstore(0x20, m1)
    8475
                mstore(0x40, m2)
    8476
                mstore(0x60, m3)
    8477
                mstore(0x80, m4)
    8478
            }
    8479
        }
    8480
    
                                                    
                                                
    8481
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    8482
            bytes32 m0;
    8483
            bytes32 m1;
    8484
            bytes32 m2;
    8485
            bytes32 m3;
    8486
            bytes32 m4;
    8487
            /// @solidity memory-safe-assembly
    8488
            assembly {
    8489
                m0 := mload(0x00)
    8490
                m1 := mload(0x20)
    8491
                m2 := mload(0x40)
    8492
                m3 := mload(0x60)
    8493
                m4 := mload(0x80)
    8494
                // Selector of `log(uint256,address,uint256,uint256)`.
    8495
                mstore(0x00, 0x0c9cd9c1)
    8496
                mstore(0x20, p0)
    8497
                mstore(0x40, p1)
    8498
                mstore(0x60, p2)
    8499
                mstore(0x80, p3)
    8500
            }
    8501
            _sendLogPayload(0x1c, 0x84);
    8502
            /// @solidity memory-safe-assembly
    8503
            assembly {
    8504
                mstore(0x00, m0)
    8505
                mstore(0x20, m1)
    8506
                mstore(0x40, m2)
    8507
                mstore(0x60, m3)
    8508
                mstore(0x80, m4)
    8509
            }
    8510
        }
    8511
    
                                                    
                                                
    8512
        function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    8513
            bytes32 m0;
    8514
            bytes32 m1;
    8515
            bytes32 m2;
    8516
            bytes32 m3;
    8517
            bytes32 m4;
    8518
            bytes32 m5;
    8519
            bytes32 m6;
    8520
            /// @solidity memory-safe-assembly
    8521
            assembly {
    8522
                function writeString(pos, w) {
    8523
                    let length := 0
    8524
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8525
                    mstore(pos, length)
    8526
                    let shift := sub(256, shl(3, length))
    8527
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8528
                }
    8529
                m0 := mload(0x00)
    8530
                m1 := mload(0x20)
    8531
                m2 := mload(0x40)
    8532
                m3 := mload(0x60)
    8533
                m4 := mload(0x80)
    8534
                m5 := mload(0xa0)
    8535
                m6 := mload(0xc0)
    8536
                // Selector of `log(uint256,address,uint256,string)`.
    8537
                mstore(0x00, 0xddb06521)
    8538
                mstore(0x20, p0)
    8539
                mstore(0x40, p1)
    8540
                mstore(0x60, p2)
    8541
                mstore(0x80, 0x80)
    8542
                writeString(0xa0, p3)
    8543
            }
    8544
            _sendLogPayload(0x1c, 0xc4);
    8545
            /// @solidity memory-safe-assembly
    8546
            assembly {
    8547
                mstore(0x00, m0)
    8548
                mstore(0x20, m1)
    8549
                mstore(0x40, m2)
    8550
                mstore(0x60, m3)
    8551
                mstore(0x80, m4)
    8552
                mstore(0xa0, m5)
    8553
                mstore(0xc0, m6)
    8554
            }
    8555
        }
    8556
    
                                                    
                                                
    8557
        function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {
    8558
            bytes32 m0;
    8559
            bytes32 m1;
    8560
            bytes32 m2;
    8561
            bytes32 m3;
    8562
            bytes32 m4;
    8563
            bytes32 m5;
    8564
            bytes32 m6;
    8565
            /// @solidity memory-safe-assembly
    8566
            assembly {
    8567
                function writeString(pos, w) {
    8568
                    let length := 0
    8569
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8570
                    mstore(pos, length)
    8571
                    let shift := sub(256, shl(3, length))
    8572
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8573
                }
    8574
                m0 := mload(0x00)
    8575
                m1 := mload(0x20)
    8576
                m2 := mload(0x40)
    8577
                m3 := mload(0x60)
    8578
                m4 := mload(0x80)
    8579
                m5 := mload(0xa0)
    8580
                m6 := mload(0xc0)
    8581
                // Selector of `log(uint256,address,string,address)`.
    8582
                mstore(0x00, 0x9cba8fff)
    8583
                mstore(0x20, p0)
    8584
                mstore(0x40, p1)
    8585
                mstore(0x60, 0x80)
    8586
                mstore(0x80, p3)
    8587
                writeString(0xa0, p2)
    8588
            }
    8589
            _sendLogPayload(0x1c, 0xc4);
    8590
            /// @solidity memory-safe-assembly
    8591
            assembly {
    8592
                mstore(0x00, m0)
    8593
                mstore(0x20, m1)
    8594
                mstore(0x40, m2)
    8595
                mstore(0x60, m3)
    8596
                mstore(0x80, m4)
    8597
                mstore(0xa0, m5)
    8598
                mstore(0xc0, m6)
    8599
            }
    8600
        }
    8601
    
                                                    
                                                
    8602
        function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {
    8603
            bytes32 m0;
    8604
            bytes32 m1;
    8605
            bytes32 m2;
    8606
            bytes32 m3;
    8607
            bytes32 m4;
    8608
            bytes32 m5;
    8609
            bytes32 m6;
    8610
            /// @solidity memory-safe-assembly
    8611
            assembly {
    8612
                function writeString(pos, w) {
    8613
                    let length := 0
    8614
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8615
                    mstore(pos, length)
    8616
                    let shift := sub(256, shl(3, length))
    8617
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8618
                }
    8619
                m0 := mload(0x00)
    8620
                m1 := mload(0x20)
    8621
                m2 := mload(0x40)
    8622
                m3 := mload(0x60)
    8623
                m4 := mload(0x80)
    8624
                m5 := mload(0xa0)
    8625
                m6 := mload(0xc0)
    8626
                // Selector of `log(uint256,address,string,bool)`.
    8627
                mstore(0x00, 0xcc32ab07)
    8628
                mstore(0x20, p0)
    8629
                mstore(0x40, p1)
    8630
                mstore(0x60, 0x80)
    8631
                mstore(0x80, p3)
    8632
                writeString(0xa0, p2)
    8633
            }
    8634
            _sendLogPayload(0x1c, 0xc4);
    8635
            /// @solidity memory-safe-assembly
    8636
            assembly {
    8637
                mstore(0x00, m0)
    8638
                mstore(0x20, m1)
    8639
                mstore(0x40, m2)
    8640
                mstore(0x60, m3)
    8641
                mstore(0x80, m4)
    8642
                mstore(0xa0, m5)
    8643
                mstore(0xc0, m6)
    8644
            }
    8645
        }
    8646
    
                                                    
                                                
    8647
        function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    8648
            bytes32 m0;
    8649
            bytes32 m1;
    8650
            bytes32 m2;
    8651
            bytes32 m3;
    8652
            bytes32 m4;
    8653
            bytes32 m5;
    8654
            bytes32 m6;
    8655
            /// @solidity memory-safe-assembly
    8656
            assembly {
    8657
                function writeString(pos, w) {
    8658
                    let length := 0
    8659
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8660
                    mstore(pos, length)
    8661
                    let shift := sub(256, shl(3, length))
    8662
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8663
                }
    8664
                m0 := mload(0x00)
    8665
                m1 := mload(0x20)
    8666
                m2 := mload(0x40)
    8667
                m3 := mload(0x60)
    8668
                m4 := mload(0x80)
    8669
                m5 := mload(0xa0)
    8670
                m6 := mload(0xc0)
    8671
                // Selector of `log(uint256,address,string,uint256)`.
    8672
                mstore(0x00, 0x46826b5d)
    8673
                mstore(0x20, p0)
    8674
                mstore(0x40, p1)
    8675
                mstore(0x60, 0x80)
    8676
                mstore(0x80, p3)
    8677
                writeString(0xa0, p2)
    8678
            }
    8679
            _sendLogPayload(0x1c, 0xc4);
    8680
            /// @solidity memory-safe-assembly
    8681
            assembly {
    8682
                mstore(0x00, m0)
    8683
                mstore(0x20, m1)
    8684
                mstore(0x40, m2)
    8685
                mstore(0x60, m3)
    8686
                mstore(0x80, m4)
    8687
                mstore(0xa0, m5)
    8688
                mstore(0xc0, m6)
    8689
            }
    8690
        }
    8691
    
                                                    
                                                
    8692
        function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    8693
            bytes32 m0;
    8694
            bytes32 m1;
    8695
            bytes32 m2;
    8696
            bytes32 m3;
    8697
            bytes32 m4;
    8698
            bytes32 m5;
    8699
            bytes32 m6;
    8700
            bytes32 m7;
    8701
            bytes32 m8;
    8702
            /// @solidity memory-safe-assembly
    8703
            assembly {
    8704
                function writeString(pos, w) {
    8705
                    let length := 0
    8706
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8707
                    mstore(pos, length)
    8708
                    let shift := sub(256, shl(3, length))
    8709
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8710
                }
    8711
                m0 := mload(0x00)
    8712
                m1 := mload(0x20)
    8713
                m2 := mload(0x40)
    8714
                m3 := mload(0x60)
    8715
                m4 := mload(0x80)
    8716
                m5 := mload(0xa0)
    8717
                m6 := mload(0xc0)
    8718
                m7 := mload(0xe0)
    8719
                m8 := mload(0x100)
    8720
                // Selector of `log(uint256,address,string,string)`.
    8721
                mstore(0x00, 0x3e128ca3)
    8722
                mstore(0x20, p0)
    8723
                mstore(0x40, p1)
    8724
                mstore(0x60, 0x80)
    8725
                mstore(0x80, 0xc0)
    8726
                writeString(0xa0, p2)
    8727
                writeString(0xe0, p3)
    8728
            }
    8729
            _sendLogPayload(0x1c, 0x104);
    8730
            /// @solidity memory-safe-assembly
    8731
            assembly {
    8732
                mstore(0x00, m0)
    8733
                mstore(0x20, m1)
    8734
                mstore(0x40, m2)
    8735
                mstore(0x60, m3)
    8736
                mstore(0x80, m4)
    8737
                mstore(0xa0, m5)
    8738
                mstore(0xc0, m6)
    8739
                mstore(0xe0, m7)
    8740
                mstore(0x100, m8)
    8741
            }
    8742
        }
    8743
    
                                                    
                                                
    8744
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    8745
            bytes32 m0;
    8746
            bytes32 m1;
    8747
            bytes32 m2;
    8748
            bytes32 m3;
    8749
            bytes32 m4;
    8750
            /// @solidity memory-safe-assembly
    8751
            assembly {
    8752
                m0 := mload(0x00)
    8753
                m1 := mload(0x20)
    8754
                m2 := mload(0x40)
    8755
                m3 := mload(0x60)
    8756
                m4 := mload(0x80)
    8757
                // Selector of `log(uint256,bool,address,address)`.
    8758
                mstore(0x00, 0xa1ef4cbb)
    8759
                mstore(0x20, p0)
    8760
                mstore(0x40, p1)
    8761
                mstore(0x60, p2)
    8762
                mstore(0x80, p3)
    8763
            }
    8764
            _sendLogPayload(0x1c, 0x84);
    8765
            /// @solidity memory-safe-assembly
    8766
            assembly {
    8767
                mstore(0x00, m0)
    8768
                mstore(0x20, m1)
    8769
                mstore(0x40, m2)
    8770
                mstore(0x60, m3)
    8771
                mstore(0x80, m4)
    8772
            }
    8773
        }
    8774
    
                                                    
                                                
    8775
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    8776
            bytes32 m0;
    8777
            bytes32 m1;
    8778
            bytes32 m2;
    8779
            bytes32 m3;
    8780
            bytes32 m4;
    8781
            /// @solidity memory-safe-assembly
    8782
            assembly {
    8783
                m0 := mload(0x00)
    8784
                m1 := mload(0x20)
    8785
                m2 := mload(0x40)
    8786
                m3 := mload(0x60)
    8787
                m4 := mload(0x80)
    8788
                // Selector of `log(uint256,bool,address,bool)`.
    8789
                mstore(0x00, 0x454d54a5)
    8790
                mstore(0x20, p0)
    8791
                mstore(0x40, p1)
    8792
                mstore(0x60, p2)
    8793
                mstore(0x80, p3)
    8794
            }
    8795
            _sendLogPayload(0x1c, 0x84);
    8796
            /// @solidity memory-safe-assembly
    8797
            assembly {
    8798
                mstore(0x00, m0)
    8799
                mstore(0x20, m1)
    8800
                mstore(0x40, m2)
    8801
                mstore(0x60, m3)
    8802
                mstore(0x80, m4)
    8803
            }
    8804
        }
    8805
    
                                                    
                                                
    8806
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    8807
            bytes32 m0;
    8808
            bytes32 m1;
    8809
            bytes32 m2;
    8810
            bytes32 m3;
    8811
            bytes32 m4;
    8812
            /// @solidity memory-safe-assembly
    8813
            assembly {
    8814
                m0 := mload(0x00)
    8815
                m1 := mload(0x20)
    8816
                m2 := mload(0x40)
    8817
                m3 := mload(0x60)
    8818
                m4 := mload(0x80)
    8819
                // Selector of `log(uint256,bool,address,uint256)`.
    8820
                mstore(0x00, 0x078287f5)
    8821
                mstore(0x20, p0)
    8822
                mstore(0x40, p1)
    8823
                mstore(0x60, p2)
    8824
                mstore(0x80, p3)
    8825
            }
    8826
            _sendLogPayload(0x1c, 0x84);
    8827
            /// @solidity memory-safe-assembly
    8828
            assembly {
    8829
                mstore(0x00, m0)
    8830
                mstore(0x20, m1)
    8831
                mstore(0x40, m2)
    8832
                mstore(0x60, m3)
    8833
                mstore(0x80, m4)
    8834
            }
    8835
        }
    8836
    
                                                    
                                                
    8837
        function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {
    8838
            bytes32 m0;
    8839
            bytes32 m1;
    8840
            bytes32 m2;
    8841
            bytes32 m3;
    8842
            bytes32 m4;
    8843
            bytes32 m5;
    8844
            bytes32 m6;
    8845
            /// @solidity memory-safe-assembly
    8846
            assembly {
    8847
                function writeString(pos, w) {
    8848
                    let length := 0
    8849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8850
                    mstore(pos, length)
    8851
                    let shift := sub(256, shl(3, length))
    8852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8853
                }
    8854
                m0 := mload(0x00)
    8855
                m1 := mload(0x20)
    8856
                m2 := mload(0x40)
    8857
                m3 := mload(0x60)
    8858
                m4 := mload(0x80)
    8859
                m5 := mload(0xa0)
    8860
                m6 := mload(0xc0)
    8861
                // Selector of `log(uint256,bool,address,string)`.
    8862
                mstore(0x00, 0xade052c7)
    8863
                mstore(0x20, p0)
    8864
                mstore(0x40, p1)
    8865
                mstore(0x60, p2)
    8866
                mstore(0x80, 0x80)
    8867
                writeString(0xa0, p3)
    8868
            }
    8869
            _sendLogPayload(0x1c, 0xc4);
    8870
            /// @solidity memory-safe-assembly
    8871
            assembly {
    8872
                mstore(0x00, m0)
    8873
                mstore(0x20, m1)
    8874
                mstore(0x40, m2)
    8875
                mstore(0x60, m3)
    8876
                mstore(0x80, m4)
    8877
                mstore(0xa0, m5)
    8878
                mstore(0xc0, m6)
    8879
            }
    8880
        }
    8881
    
                                                    
                                                
    8882
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    8883
            bytes32 m0;
    8884
            bytes32 m1;
    8885
            bytes32 m2;
    8886
            bytes32 m3;
    8887
            bytes32 m4;
    8888
            /// @solidity memory-safe-assembly
    8889
            assembly {
    8890
                m0 := mload(0x00)
    8891
                m1 := mload(0x20)
    8892
                m2 := mload(0x40)
    8893
                m3 := mload(0x60)
    8894
                m4 := mload(0x80)
    8895
                // Selector of `log(uint256,bool,bool,address)`.
    8896
                mstore(0x00, 0x69640b59)
    8897
                mstore(0x20, p0)
    8898
                mstore(0x40, p1)
    8899
                mstore(0x60, p2)
    8900
                mstore(0x80, p3)
    8901
            }
    8902
            _sendLogPayload(0x1c, 0x84);
    8903
            /// @solidity memory-safe-assembly
    8904
            assembly {
    8905
                mstore(0x00, m0)
    8906
                mstore(0x20, m1)
    8907
                mstore(0x40, m2)
    8908
                mstore(0x60, m3)
    8909
                mstore(0x80, m4)
    8910
            }
    8911
        }
    8912
    
                                                    
                                                
    8913
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    8914
            bytes32 m0;
    8915
            bytes32 m1;
    8916
            bytes32 m2;
    8917
            bytes32 m3;
    8918
            bytes32 m4;
    8919
            /// @solidity memory-safe-assembly
    8920
            assembly {
    8921
                m0 := mload(0x00)
    8922
                m1 := mload(0x20)
    8923
                m2 := mload(0x40)
    8924
                m3 := mload(0x60)
    8925
                m4 := mload(0x80)
    8926
                // Selector of `log(uint256,bool,bool,bool)`.
    8927
                mstore(0x00, 0xb6f577a1)
    8928
                mstore(0x20, p0)
    8929
                mstore(0x40, p1)
    8930
                mstore(0x60, p2)
    8931
                mstore(0x80, p3)
    8932
            }
    8933
            _sendLogPayload(0x1c, 0x84);
    8934
            /// @solidity memory-safe-assembly
    8935
            assembly {
    8936
                mstore(0x00, m0)
    8937
                mstore(0x20, m1)
    8938
                mstore(0x40, m2)
    8939
                mstore(0x60, m3)
    8940
                mstore(0x80, m4)
    8941
            }
    8942
        }
    8943
    
                                                    
                                                
    8944
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    8945
            bytes32 m0;
    8946
            bytes32 m1;
    8947
            bytes32 m2;
    8948
            bytes32 m3;
    8949
            bytes32 m4;
    8950
            /// @solidity memory-safe-assembly
    8951
            assembly {
    8952
                m0 := mload(0x00)
    8953
                m1 := mload(0x20)
    8954
                m2 := mload(0x40)
    8955
                m3 := mload(0x60)
    8956
                m4 := mload(0x80)
    8957
                // Selector of `log(uint256,bool,bool,uint256)`.
    8958
                mstore(0x00, 0x7464ce23)
    8959
                mstore(0x20, p0)
    8960
                mstore(0x40, p1)
    8961
                mstore(0x60, p2)
    8962
                mstore(0x80, p3)
    8963
            }
    8964
            _sendLogPayload(0x1c, 0x84);
    8965
            /// @solidity memory-safe-assembly
    8966
            assembly {
    8967
                mstore(0x00, m0)
    8968
                mstore(0x20, m1)
    8969
                mstore(0x40, m2)
    8970
                mstore(0x60, m3)
    8971
                mstore(0x80, m4)
    8972
            }
    8973
        }
    8974
    
                                                    
                                                
    8975
        function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {
    8976
            bytes32 m0;
    8977
            bytes32 m1;
    8978
            bytes32 m2;
    8979
            bytes32 m3;
    8980
            bytes32 m4;
    8981
            bytes32 m5;
    8982
            bytes32 m6;
    8983
            /// @solidity memory-safe-assembly
    8984
            assembly {
    8985
                function writeString(pos, w) {
    8986
                    let length := 0
    8987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8988
                    mstore(pos, length)
    8989
                    let shift := sub(256, shl(3, length))
    8990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8991
                }
    8992
                m0 := mload(0x00)
    8993
                m1 := mload(0x20)
    8994
                m2 := mload(0x40)
    8995
                m3 := mload(0x60)
    8996
                m4 := mload(0x80)
    8997
                m5 := mload(0xa0)
    8998
                m6 := mload(0xc0)
    8999
                // Selector of `log(uint256,bool,bool,string)`.
    9000
                mstore(0x00, 0xdddb9561)
    9001
                mstore(0x20, p0)
    9002
                mstore(0x40, p1)
    9003
                mstore(0x60, p2)
    9004
                mstore(0x80, 0x80)
    9005
                writeString(0xa0, p3)
    9006
            }
    9007
            _sendLogPayload(0x1c, 0xc4);
    9008
            /// @solidity memory-safe-assembly
    9009
            assembly {
    9010
                mstore(0x00, m0)
    9011
                mstore(0x20, m1)
    9012
                mstore(0x40, m2)
    9013
                mstore(0x60, m3)
    9014
                mstore(0x80, m4)
    9015
                mstore(0xa0, m5)
    9016
                mstore(0xc0, m6)
    9017
            }
    9018
        }
    9019
    
                                                    
                                                
    9020
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    9021
            bytes32 m0;
    9022
            bytes32 m1;
    9023
            bytes32 m2;
    9024
            bytes32 m3;
    9025
            bytes32 m4;
    9026
            /// @solidity memory-safe-assembly
    9027
            assembly {
    9028
                m0 := mload(0x00)
    9029
                m1 := mload(0x20)
    9030
                m2 := mload(0x40)
    9031
                m3 := mload(0x60)
    9032
                m4 := mload(0x80)
    9033
                // Selector of `log(uint256,bool,uint256,address)`.
    9034
                mstore(0x00, 0x88cb6041)
    9035
                mstore(0x20, p0)
    9036
                mstore(0x40, p1)
    9037
                mstore(0x60, p2)
    9038
                mstore(0x80, p3)
    9039
            }
    9040
            _sendLogPayload(0x1c, 0x84);
    9041
            /// @solidity memory-safe-assembly
    9042
            assembly {
    9043
                mstore(0x00, m0)
    9044
                mstore(0x20, m1)
    9045
                mstore(0x40, m2)
    9046
                mstore(0x60, m3)
    9047
                mstore(0x80, m4)
    9048
            }
    9049
        }
    9050
    
                                                    
                                                
    9051
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    9052
            bytes32 m0;
    9053
            bytes32 m1;
    9054
            bytes32 m2;
    9055
            bytes32 m3;
    9056
            bytes32 m4;
    9057
            /// @solidity memory-safe-assembly
    9058
            assembly {
    9059
                m0 := mload(0x00)
    9060
                m1 := mload(0x20)
    9061
                m2 := mload(0x40)
    9062
                m3 := mload(0x60)
    9063
                m4 := mload(0x80)
    9064
                // Selector of `log(uint256,bool,uint256,bool)`.
    9065
                mstore(0x00, 0x91a02e2a)
    9066
                mstore(0x20, p0)
    9067
                mstore(0x40, p1)
    9068
                mstore(0x60, p2)
    9069
                mstore(0x80, p3)
    9070
            }
    9071
            _sendLogPayload(0x1c, 0x84);
    9072
            /// @solidity memory-safe-assembly
    9073
            assembly {
    9074
                mstore(0x00, m0)
    9075
                mstore(0x20, m1)
    9076
                mstore(0x40, m2)
    9077
                mstore(0x60, m3)
    9078
                mstore(0x80, m4)
    9079
            }
    9080
        }
    9081
    
                                                    
                                                
    9082
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    9083
            bytes32 m0;
    9084
            bytes32 m1;
    9085
            bytes32 m2;
    9086
            bytes32 m3;
    9087
            bytes32 m4;
    9088
            /// @solidity memory-safe-assembly
    9089
            assembly {
    9090
                m0 := mload(0x00)
    9091
                m1 := mload(0x20)
    9092
                m2 := mload(0x40)
    9093
                m3 := mload(0x60)
    9094
                m4 := mload(0x80)
    9095
                // Selector of `log(uint256,bool,uint256,uint256)`.
    9096
                mstore(0x00, 0xc6acc7a8)
    9097
                mstore(0x20, p0)
    9098
                mstore(0x40, p1)
    9099
                mstore(0x60, p2)
    9100
                mstore(0x80, p3)
    9101
            }
    9102
            _sendLogPayload(0x1c, 0x84);
    9103
            /// @solidity memory-safe-assembly
    9104
            assembly {
    9105
                mstore(0x00, m0)
    9106
                mstore(0x20, m1)
    9107
                mstore(0x40, m2)
    9108
                mstore(0x60, m3)
    9109
                mstore(0x80, m4)
    9110
            }
    9111
        }
    9112
    
                                                    
                                                
    9113
        function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    9114
            bytes32 m0;
    9115
            bytes32 m1;
    9116
            bytes32 m2;
    9117
            bytes32 m3;
    9118
            bytes32 m4;
    9119
            bytes32 m5;
    9120
            bytes32 m6;
    9121
            /// @solidity memory-safe-assembly
    9122
            assembly {
    9123
                function writeString(pos, w) {
    9124
                    let length := 0
    9125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9126
                    mstore(pos, length)
    9127
                    let shift := sub(256, shl(3, length))
    9128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9129
                }
    9130
                m0 := mload(0x00)
    9131
                m1 := mload(0x20)
    9132
                m2 := mload(0x40)
    9133
                m3 := mload(0x60)
    9134
                m4 := mload(0x80)
    9135
                m5 := mload(0xa0)
    9136
                m6 := mload(0xc0)
    9137
                // Selector of `log(uint256,bool,uint256,string)`.
    9138
                mstore(0x00, 0xde03e774)
    9139
                mstore(0x20, p0)
    9140
                mstore(0x40, p1)
    9141
                mstore(0x60, p2)
    9142
                mstore(0x80, 0x80)
    9143
                writeString(0xa0, p3)
    9144
            }
    9145
            _sendLogPayload(0x1c, 0xc4);
    9146
            /// @solidity memory-safe-assembly
    9147
            assembly {
    9148
                mstore(0x00, m0)
    9149
                mstore(0x20, m1)
    9150
                mstore(0x40, m2)
    9151
                mstore(0x60, m3)
    9152
                mstore(0x80, m4)
    9153
                mstore(0xa0, m5)
    9154
                mstore(0xc0, m6)
    9155
            }
    9156
        }
    9157
    
                                                    
                                                
    9158
        function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {
    9159
            bytes32 m0;
    9160
            bytes32 m1;
    9161
            bytes32 m2;
    9162
            bytes32 m3;
    9163
            bytes32 m4;
    9164
            bytes32 m5;
    9165
            bytes32 m6;
    9166
            /// @solidity memory-safe-assembly
    9167
            assembly {
    9168
                function writeString(pos, w) {
    9169
                    let length := 0
    9170
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9171
                    mstore(pos, length)
    9172
                    let shift := sub(256, shl(3, length))
    9173
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9174
                }
    9175
                m0 := mload(0x00)
    9176
                m1 := mload(0x20)
    9177
                m2 := mload(0x40)
    9178
                m3 := mload(0x60)
    9179
                m4 := mload(0x80)
    9180
                m5 := mload(0xa0)
    9181
                m6 := mload(0xc0)
    9182
                // Selector of `log(uint256,bool,string,address)`.
    9183
                mstore(0x00, 0xef529018)
    9184
                mstore(0x20, p0)
    9185
                mstore(0x40, p1)
    9186
                mstore(0x60, 0x80)
    9187
                mstore(0x80, p3)
    9188
                writeString(0xa0, p2)
    9189
            }
    9190
            _sendLogPayload(0x1c, 0xc4);
    9191
            /// @solidity memory-safe-assembly
    9192
            assembly {
    9193
                mstore(0x00, m0)
    9194
                mstore(0x20, m1)
    9195
                mstore(0x40, m2)
    9196
                mstore(0x60, m3)
    9197
                mstore(0x80, m4)
    9198
                mstore(0xa0, m5)
    9199
                mstore(0xc0, m6)
    9200
            }
    9201
        }
    9202
    
                                                    
                                                
    9203
        function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {
    9204
            bytes32 m0;
    9205
            bytes32 m1;
    9206
            bytes32 m2;
    9207
            bytes32 m3;
    9208
            bytes32 m4;
    9209
            bytes32 m5;
    9210
            bytes32 m6;
    9211
            /// @solidity memory-safe-assembly
    9212
            assembly {
    9213
                function writeString(pos, w) {
    9214
                    let length := 0
    9215
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9216
                    mstore(pos, length)
    9217
                    let shift := sub(256, shl(3, length))
    9218
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9219
                }
    9220
                m0 := mload(0x00)
    9221
                m1 := mload(0x20)
    9222
                m2 := mload(0x40)
    9223
                m3 := mload(0x60)
    9224
                m4 := mload(0x80)
    9225
                m5 := mload(0xa0)
    9226
                m6 := mload(0xc0)
    9227
                // Selector of `log(uint256,bool,string,bool)`.
    9228
                mstore(0x00, 0xeb928d7f)
    9229
                mstore(0x20, p0)
    9230
                mstore(0x40, p1)
    9231
                mstore(0x60, 0x80)
    9232
                mstore(0x80, p3)
    9233
                writeString(0xa0, p2)
    9234
            }
    9235
            _sendLogPayload(0x1c, 0xc4);
    9236
            /// @solidity memory-safe-assembly
    9237
            assembly {
    9238
                mstore(0x00, m0)
    9239
                mstore(0x20, m1)
    9240
                mstore(0x40, m2)
    9241
                mstore(0x60, m3)
    9242
                mstore(0x80, m4)
    9243
                mstore(0xa0, m5)
    9244
                mstore(0xc0, m6)
    9245
            }
    9246
        }
    9247
    
                                                    
                                                
    9248
        function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    9249
            bytes32 m0;
    9250
            bytes32 m1;
    9251
            bytes32 m2;
    9252
            bytes32 m3;
    9253
            bytes32 m4;
    9254
            bytes32 m5;
    9255
            bytes32 m6;
    9256
            /// @solidity memory-safe-assembly
    9257
            assembly {
    9258
                function writeString(pos, w) {
    9259
                    let length := 0
    9260
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9261
                    mstore(pos, length)
    9262
                    let shift := sub(256, shl(3, length))
    9263
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9264
                }
    9265
                m0 := mload(0x00)
    9266
                m1 := mload(0x20)
    9267
                m2 := mload(0x40)
    9268
                m3 := mload(0x60)
    9269
                m4 := mload(0x80)
    9270
                m5 := mload(0xa0)
    9271
                m6 := mload(0xc0)
    9272
                // Selector of `log(uint256,bool,string,uint256)`.
    9273
                mstore(0x00, 0x2c1d0746)
    9274
                mstore(0x20, p0)
    9275
                mstore(0x40, p1)
    9276
                mstore(0x60, 0x80)
    9277
                mstore(0x80, p3)
    9278
                writeString(0xa0, p2)
    9279
            }
    9280
            _sendLogPayload(0x1c, 0xc4);
    9281
            /// @solidity memory-safe-assembly
    9282
            assembly {
    9283
                mstore(0x00, m0)
    9284
                mstore(0x20, m1)
    9285
                mstore(0x40, m2)
    9286
                mstore(0x60, m3)
    9287
                mstore(0x80, m4)
    9288
                mstore(0xa0, m5)
    9289
                mstore(0xc0, m6)
    9290
            }
    9291
        }
    9292
    
                                                    
                                                
    9293
        function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    9294
            bytes32 m0;
    9295
            bytes32 m1;
    9296
            bytes32 m2;
    9297
            bytes32 m3;
    9298
            bytes32 m4;
    9299
            bytes32 m5;
    9300
            bytes32 m6;
    9301
            bytes32 m7;
    9302
            bytes32 m8;
    9303
            /// @solidity memory-safe-assembly
    9304
            assembly {
    9305
                function writeString(pos, w) {
    9306
                    let length := 0
    9307
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9308
                    mstore(pos, length)
    9309
                    let shift := sub(256, shl(3, length))
    9310
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9311
                }
    9312
                m0 := mload(0x00)
    9313
                m1 := mload(0x20)
    9314
                m2 := mload(0x40)
    9315
                m3 := mload(0x60)
    9316
                m4 := mload(0x80)
    9317
                m5 := mload(0xa0)
    9318
                m6 := mload(0xc0)
    9319
                m7 := mload(0xe0)
    9320
                m8 := mload(0x100)
    9321
                // Selector of `log(uint256,bool,string,string)`.
    9322
                mstore(0x00, 0x68c8b8bd)
    9323
                mstore(0x20, p0)
    9324
                mstore(0x40, p1)
    9325
                mstore(0x60, 0x80)
    9326
                mstore(0x80, 0xc0)
    9327
                writeString(0xa0, p2)
    9328
                writeString(0xe0, p3)
    9329
            }
    9330
            _sendLogPayload(0x1c, 0x104);
    9331
            /// @solidity memory-safe-assembly
    9332
            assembly {
    9333
                mstore(0x00, m0)
    9334
                mstore(0x20, m1)
    9335
                mstore(0x40, m2)
    9336
                mstore(0x60, m3)
    9337
                mstore(0x80, m4)
    9338
                mstore(0xa0, m5)
    9339
                mstore(0xc0, m6)
    9340
                mstore(0xe0, m7)
    9341
                mstore(0x100, m8)
    9342
            }
    9343
        }
    9344
    
                                                    
                                                
    9345
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    9346
            bytes32 m0;
    9347
            bytes32 m1;
    9348
            bytes32 m2;
    9349
            bytes32 m3;
    9350
            bytes32 m4;
    9351
            /// @solidity memory-safe-assembly
    9352
            assembly {
    9353
                m0 := mload(0x00)
    9354
                m1 := mload(0x20)
    9355
                m2 := mload(0x40)
    9356
                m3 := mload(0x60)
    9357
                m4 := mload(0x80)
    9358
                // Selector of `log(uint256,uint256,address,address)`.
    9359
                mstore(0x00, 0x56a5d1b1)
    9360
                mstore(0x20, p0)
    9361
                mstore(0x40, p1)
    9362
                mstore(0x60, p2)
    9363
                mstore(0x80, p3)
    9364
            }
    9365
            _sendLogPayload(0x1c, 0x84);
    9366
            /// @solidity memory-safe-assembly
    9367
            assembly {
    9368
                mstore(0x00, m0)
    9369
                mstore(0x20, m1)
    9370
                mstore(0x40, m2)
    9371
                mstore(0x60, m3)
    9372
                mstore(0x80, m4)
    9373
            }
    9374
        }
    9375
    
                                                    
                                                
    9376
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    9377
            bytes32 m0;
    9378
            bytes32 m1;
    9379
            bytes32 m2;
    9380
            bytes32 m3;
    9381
            bytes32 m4;
    9382
            /// @solidity memory-safe-assembly
    9383
            assembly {
    9384
                m0 := mload(0x00)
    9385
                m1 := mload(0x20)
    9386
                m2 := mload(0x40)
    9387
                m3 := mload(0x60)
    9388
                m4 := mload(0x80)
    9389
                // Selector of `log(uint256,uint256,address,bool)`.
    9390
                mstore(0x00, 0x15cac476)
    9391
                mstore(0x20, p0)
    9392
                mstore(0x40, p1)
    9393
                mstore(0x60, p2)
    9394
                mstore(0x80, p3)
    9395
            }
    9396
            _sendLogPayload(0x1c, 0x84);
    9397
            /// @solidity memory-safe-assembly
    9398
            assembly {
    9399
                mstore(0x00, m0)
    9400
                mstore(0x20, m1)
    9401
                mstore(0x40, m2)
    9402
                mstore(0x60, m3)
    9403
                mstore(0x80, m4)
    9404
            }
    9405
        }
    9406
    
                                                    
                                                
    9407
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    9408
            bytes32 m0;
    9409
            bytes32 m1;
    9410
            bytes32 m2;
    9411
            bytes32 m3;
    9412
            bytes32 m4;
    9413
            /// @solidity memory-safe-assembly
    9414
            assembly {
    9415
                m0 := mload(0x00)
    9416
                m1 := mload(0x20)
    9417
                m2 := mload(0x40)
    9418
                m3 := mload(0x60)
    9419
                m4 := mload(0x80)
    9420
                // Selector of `log(uint256,uint256,address,uint256)`.
    9421
                mstore(0x00, 0x88f6e4b2)
    9422
                mstore(0x20, p0)
    9423
                mstore(0x40, p1)
    9424
                mstore(0x60, p2)
    9425
                mstore(0x80, p3)
    9426
            }
    9427
            _sendLogPayload(0x1c, 0x84);
    9428
            /// @solidity memory-safe-assembly
    9429
            assembly {
    9430
                mstore(0x00, m0)
    9431
                mstore(0x20, m1)
    9432
                mstore(0x40, m2)
    9433
                mstore(0x60, m3)
    9434
                mstore(0x80, m4)
    9435
            }
    9436
        }
    9437
    
                                                    
                                                
    9438
        function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    9439
            bytes32 m0;
    9440
            bytes32 m1;
    9441
            bytes32 m2;
    9442
            bytes32 m3;
    9443
            bytes32 m4;
    9444
            bytes32 m5;
    9445
            bytes32 m6;
    9446
            /// @solidity memory-safe-assembly
    9447
            assembly {
    9448
                function writeString(pos, w) {
    9449
                    let length := 0
    9450
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9451
                    mstore(pos, length)
    9452
                    let shift := sub(256, shl(3, length))
    9453
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9454
                }
    9455
                m0 := mload(0x00)
    9456
                m1 := mload(0x20)
    9457
                m2 := mload(0x40)
    9458
                m3 := mload(0x60)
    9459
                m4 := mload(0x80)
    9460
                m5 := mload(0xa0)
    9461
                m6 := mload(0xc0)
    9462
                // Selector of `log(uint256,uint256,address,string)`.
    9463
                mstore(0x00, 0x6cde40b8)
    9464
                mstore(0x20, p0)
    9465
                mstore(0x40, p1)
    9466
                mstore(0x60, p2)
    9467
                mstore(0x80, 0x80)
    9468
                writeString(0xa0, p3)
    9469
            }
    9470
            _sendLogPayload(0x1c, 0xc4);
    9471
            /// @solidity memory-safe-assembly
    9472
            assembly {
    9473
                mstore(0x00, m0)
    9474
                mstore(0x20, m1)
    9475
                mstore(0x40, m2)
    9476
                mstore(0x60, m3)
    9477
                mstore(0x80, m4)
    9478
                mstore(0xa0, m5)
    9479
                mstore(0xc0, m6)
    9480
            }
    9481
        }
    9482
    
                                                    
                                                
    9483
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    9484
            bytes32 m0;
    9485
            bytes32 m1;
    9486
            bytes32 m2;
    9487
            bytes32 m3;
    9488
            bytes32 m4;
    9489
            /// @solidity memory-safe-assembly
    9490
            assembly {
    9491
                m0 := mload(0x00)
    9492
                m1 := mload(0x20)
    9493
                m2 := mload(0x40)
    9494
                m3 := mload(0x60)
    9495
                m4 := mload(0x80)
    9496
                // Selector of `log(uint256,uint256,bool,address)`.
    9497
                mstore(0x00, 0x9a816a83)
    9498
                mstore(0x20, p0)
    9499
                mstore(0x40, p1)
    9500
                mstore(0x60, p2)
    9501
                mstore(0x80, p3)
    9502
            }
    9503
            _sendLogPayload(0x1c, 0x84);
    9504
            /// @solidity memory-safe-assembly
    9505
            assembly {
    9506
                mstore(0x00, m0)
    9507
                mstore(0x20, m1)
    9508
                mstore(0x40, m2)
    9509
                mstore(0x60, m3)
    9510
                mstore(0x80, m4)
    9511
            }
    9512
        }
    9513
    
                                                    
                                                
    9514
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    9515
            bytes32 m0;
    9516
            bytes32 m1;
    9517
            bytes32 m2;
    9518
            bytes32 m3;
    9519
            bytes32 m4;
    9520
            /// @solidity memory-safe-assembly
    9521
            assembly {
    9522
                m0 := mload(0x00)
    9523
                m1 := mload(0x20)
    9524
                m2 := mload(0x40)
    9525
                m3 := mload(0x60)
    9526
                m4 := mload(0x80)
    9527
                // Selector of `log(uint256,uint256,bool,bool)`.
    9528
                mstore(0x00, 0xab085ae6)
    9529
                mstore(0x20, p0)
    9530
                mstore(0x40, p1)
    9531
                mstore(0x60, p2)
    9532
                mstore(0x80, p3)
    9533
            }
    9534
            _sendLogPayload(0x1c, 0x84);
    9535
            /// @solidity memory-safe-assembly
    9536
            assembly {
    9537
                mstore(0x00, m0)
    9538
                mstore(0x20, m1)
    9539
                mstore(0x40, m2)
    9540
                mstore(0x60, m3)
    9541
                mstore(0x80, m4)
    9542
            }
    9543
        }
    9544
    
                                                    
                                                
    9545
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    9546
            bytes32 m0;
    9547
            bytes32 m1;
    9548
            bytes32 m2;
    9549
            bytes32 m3;
    9550
            bytes32 m4;
    9551
            /// @solidity memory-safe-assembly
    9552
            assembly {
    9553
                m0 := mload(0x00)
    9554
                m1 := mload(0x20)
    9555
                m2 := mload(0x40)
    9556
                m3 := mload(0x60)
    9557
                m4 := mload(0x80)
    9558
                // Selector of `log(uint256,uint256,bool,uint256)`.
    9559
                mstore(0x00, 0xeb7f6fd2)
    9560
                mstore(0x20, p0)
    9561
                mstore(0x40, p1)
    9562
                mstore(0x60, p2)
    9563
                mstore(0x80, p3)
    9564
            }
    9565
            _sendLogPayload(0x1c, 0x84);
    9566
            /// @solidity memory-safe-assembly
    9567
            assembly {
    9568
                mstore(0x00, m0)
    9569
                mstore(0x20, m1)
    9570
                mstore(0x40, m2)
    9571
                mstore(0x60, m3)
    9572
                mstore(0x80, m4)
    9573
            }
    9574
        }
    9575
    
                                                    
                                                
    9576
        function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    9577
            bytes32 m0;
    9578
            bytes32 m1;
    9579
            bytes32 m2;
    9580
            bytes32 m3;
    9581
            bytes32 m4;
    9582
            bytes32 m5;
    9583
            bytes32 m6;
    9584
            /// @solidity memory-safe-assembly
    9585
            assembly {
    9586
                function writeString(pos, w) {
    9587
                    let length := 0
    9588
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9589
                    mstore(pos, length)
    9590
                    let shift := sub(256, shl(3, length))
    9591
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9592
                }
    9593
                m0 := mload(0x00)
    9594
                m1 := mload(0x20)
    9595
                m2 := mload(0x40)
    9596
                m3 := mload(0x60)
    9597
                m4 := mload(0x80)
    9598
                m5 := mload(0xa0)
    9599
                m6 := mload(0xc0)
    9600
                // Selector of `log(uint256,uint256,bool,string)`.
    9601
                mstore(0x00, 0xa5b4fc99)
    9602
                mstore(0x20, p0)
    9603
                mstore(0x40, p1)
    9604
                mstore(0x60, p2)
    9605
                mstore(0x80, 0x80)
    9606
                writeString(0xa0, p3)
    9607
            }
    9608
            _sendLogPayload(0x1c, 0xc4);
    9609
            /// @solidity memory-safe-assembly
    9610
            assembly {
    9611
                mstore(0x00, m0)
    9612
                mstore(0x20, m1)
    9613
                mstore(0x40, m2)
    9614
                mstore(0x60, m3)
    9615
                mstore(0x80, m4)
    9616
                mstore(0xa0, m5)
    9617
                mstore(0xc0, m6)
    9618
            }
    9619
        }
    9620
    
                                                    
                                                
    9621
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    9622
            bytes32 m0;
    9623
            bytes32 m1;
    9624
            bytes32 m2;
    9625
            bytes32 m3;
    9626
            bytes32 m4;
    9627
            /// @solidity memory-safe-assembly
    9628
            assembly {
    9629
                m0 := mload(0x00)
    9630
                m1 := mload(0x20)
    9631
                m2 := mload(0x40)
    9632
                m3 := mload(0x60)
    9633
                m4 := mload(0x80)
    9634
                // Selector of `log(uint256,uint256,uint256,address)`.
    9635
                mstore(0x00, 0xfa8185af)
    9636
                mstore(0x20, p0)
    9637
                mstore(0x40, p1)
    9638
                mstore(0x60, p2)
    9639
                mstore(0x80, p3)
    9640
            }
    9641
            _sendLogPayload(0x1c, 0x84);
    9642
            /// @solidity memory-safe-assembly
    9643
            assembly {
    9644
                mstore(0x00, m0)
    9645
                mstore(0x20, m1)
    9646
                mstore(0x40, m2)
    9647
                mstore(0x60, m3)
    9648
                mstore(0x80, m4)
    9649
            }
    9650
        }
    9651
    
                                                    
                                                
    9652
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    9653
            bytes32 m0;
    9654
            bytes32 m1;
    9655
            bytes32 m2;
    9656
            bytes32 m3;
    9657
            bytes32 m4;
    9658
            /// @solidity memory-safe-assembly
    9659
            assembly {
    9660
                m0 := mload(0x00)
    9661
                m1 := mload(0x20)
    9662
                m2 := mload(0x40)
    9663
                m3 := mload(0x60)
    9664
                m4 := mload(0x80)
    9665
                // Selector of `log(uint256,uint256,uint256,bool)`.
    9666
                mstore(0x00, 0xc598d185)
    9667
                mstore(0x20, p0)
    9668
                mstore(0x40, p1)
    9669
                mstore(0x60, p2)
    9670
                mstore(0x80, p3)
    9671
            }
    9672
            _sendLogPayload(0x1c, 0x84);
    9673
            /// @solidity memory-safe-assembly
    9674
            assembly {
    9675
                mstore(0x00, m0)
    9676
                mstore(0x20, m1)
    9677
                mstore(0x40, m2)
    9678
                mstore(0x60, m3)
    9679
                mstore(0x80, m4)
    9680
            }
    9681
        }
    9682
    
                                                    
                                                
    9683
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    9684
            bytes32 m0;
    9685
            bytes32 m1;
    9686
            bytes32 m2;
    9687
            bytes32 m3;
    9688
            bytes32 m4;
    9689
            /// @solidity memory-safe-assembly
    9690
            assembly {
    9691
                m0 := mload(0x00)
    9692
                m1 := mload(0x20)
    9693
                m2 := mload(0x40)
    9694
                m3 := mload(0x60)
    9695
                m4 := mload(0x80)
    9696
                // Selector of `log(uint256,uint256,uint256,uint256)`.
    9697
                mstore(0x00, 0x193fb800)
    9698
                mstore(0x20, p0)
    9699
                mstore(0x40, p1)
    9700
                mstore(0x60, p2)
    9701
                mstore(0x80, p3)
    9702
            }
    9703
            _sendLogPayload(0x1c, 0x84);
    9704
            /// @solidity memory-safe-assembly
    9705
            assembly {
    9706
                mstore(0x00, m0)
    9707
                mstore(0x20, m1)
    9708
                mstore(0x40, m2)
    9709
                mstore(0x60, m3)
    9710
                mstore(0x80, m4)
    9711
            }
    9712
        }
    9713
    
                                                    
                                                
    9714
        function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    9715
            bytes32 m0;
    9716
            bytes32 m1;
    9717
            bytes32 m2;
    9718
            bytes32 m3;
    9719
            bytes32 m4;
    9720
            bytes32 m5;
    9721
            bytes32 m6;
    9722
            /// @solidity memory-safe-assembly
    9723
            assembly {
    9724
                function writeString(pos, w) {
    9725
                    let length := 0
    9726
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9727
                    mstore(pos, length)
    9728
                    let shift := sub(256, shl(3, length))
    9729
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9730
                }
    9731
                m0 := mload(0x00)
    9732
                m1 := mload(0x20)
    9733
                m2 := mload(0x40)
    9734
                m3 := mload(0x60)
    9735
                m4 := mload(0x80)
    9736
                m5 := mload(0xa0)
    9737
                m6 := mload(0xc0)
    9738
                // Selector of `log(uint256,uint256,uint256,string)`.
    9739
                mstore(0x00, 0x59cfcbe3)
    9740
                mstore(0x20, p0)
    9741
                mstore(0x40, p1)
    9742
                mstore(0x60, p2)
    9743
                mstore(0x80, 0x80)
    9744
                writeString(0xa0, p3)
    9745
            }
    9746
            _sendLogPayload(0x1c, 0xc4);
    9747
            /// @solidity memory-safe-assembly
    9748
            assembly {
    9749
                mstore(0x00, m0)
    9750
                mstore(0x20, m1)
    9751
                mstore(0x40, m2)
    9752
                mstore(0x60, m3)
    9753
                mstore(0x80, m4)
    9754
                mstore(0xa0, m5)
    9755
                mstore(0xc0, m6)
    9756
            }
    9757
        }
    9758
    
                                                    
                                                
    9759
        function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    9760
            bytes32 m0;
    9761
            bytes32 m1;
    9762
            bytes32 m2;
    9763
            bytes32 m3;
    9764
            bytes32 m4;
    9765
            bytes32 m5;
    9766
            bytes32 m6;
    9767
            /// @solidity memory-safe-assembly
    9768
            assembly {
    9769
                function writeString(pos, w) {
    9770
                    let length := 0
    9771
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9772
                    mstore(pos, length)
    9773
                    let shift := sub(256, shl(3, length))
    9774
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9775
                }
    9776
                m0 := mload(0x00)
    9777
                m1 := mload(0x20)
    9778
                m2 := mload(0x40)
    9779
                m3 := mload(0x60)
    9780
                m4 := mload(0x80)
    9781
                m5 := mload(0xa0)
    9782
                m6 := mload(0xc0)
    9783
                // Selector of `log(uint256,uint256,string,address)`.
    9784
                mstore(0x00, 0x42d21db7)
    9785
                mstore(0x20, p0)
    9786
                mstore(0x40, p1)
    9787
                mstore(0x60, 0x80)
    9788
                mstore(0x80, p3)
    9789
                writeString(0xa0, p2)
    9790
            }
    9791
            _sendLogPayload(0x1c, 0xc4);
    9792
            /// @solidity memory-safe-assembly
    9793
            assembly {
    9794
                mstore(0x00, m0)
    9795
                mstore(0x20, m1)
    9796
                mstore(0x40, m2)
    9797
                mstore(0x60, m3)
    9798
                mstore(0x80, m4)
    9799
                mstore(0xa0, m5)
    9800
                mstore(0xc0, m6)
    9801
            }
    9802
        }
    9803
    
                                                    
                                                
    9804
        function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    9805
            bytes32 m0;
    9806
            bytes32 m1;
    9807
            bytes32 m2;
    9808
            bytes32 m3;
    9809
            bytes32 m4;
    9810
            bytes32 m5;
    9811
            bytes32 m6;
    9812
            /// @solidity memory-safe-assembly
    9813
            assembly {
    9814
                function writeString(pos, w) {
    9815
                    let length := 0
    9816
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9817
                    mstore(pos, length)
    9818
                    let shift := sub(256, shl(3, length))
    9819
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9820
                }
    9821
                m0 := mload(0x00)
    9822
                m1 := mload(0x20)
    9823
                m2 := mload(0x40)
    9824
                m3 := mload(0x60)
    9825
                m4 := mload(0x80)
    9826
                m5 := mload(0xa0)
    9827
                m6 := mload(0xc0)
    9828
                // Selector of `log(uint256,uint256,string,bool)`.
    9829
                mstore(0x00, 0x7af6ab25)
    9830
                mstore(0x20, p0)
    9831
                mstore(0x40, p1)
    9832
                mstore(0x60, 0x80)
    9833
                mstore(0x80, p3)
    9834
                writeString(0xa0, p2)
    9835
            }
    9836
            _sendLogPayload(0x1c, 0xc4);
    9837
            /// @solidity memory-safe-assembly
    9838
            assembly {
    9839
                mstore(0x00, m0)
    9840
                mstore(0x20, m1)
    9841
                mstore(0x40, m2)
    9842
                mstore(0x60, m3)
    9843
                mstore(0x80, m4)
    9844
                mstore(0xa0, m5)
    9845
                mstore(0xc0, m6)
    9846
            }
    9847
        }
    9848
    
                                                    
                                                
    9849
        function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    9850
            bytes32 m0;
    9851
            bytes32 m1;
    9852
            bytes32 m2;
    9853
            bytes32 m3;
    9854
            bytes32 m4;
    9855
            bytes32 m5;
    9856
            bytes32 m6;
    9857
            /// @solidity memory-safe-assembly
    9858
            assembly {
    9859
                function writeString(pos, w) {
    9860
                    let length := 0
    9861
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9862
                    mstore(pos, length)
    9863
                    let shift := sub(256, shl(3, length))
    9864
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9865
                }
    9866
                m0 := mload(0x00)
    9867
                m1 := mload(0x20)
    9868
                m2 := mload(0x40)
    9869
                m3 := mload(0x60)
    9870
                m4 := mload(0x80)
    9871
                m5 := mload(0xa0)
    9872
                m6 := mload(0xc0)
    9873
                // Selector of `log(uint256,uint256,string,uint256)`.
    9874
                mstore(0x00, 0x5da297eb)
    9875
                mstore(0x20, p0)
    9876
                mstore(0x40, p1)
    9877
                mstore(0x60, 0x80)
    9878
                mstore(0x80, p3)
    9879
                writeString(0xa0, p2)
    9880
            }
    9881
            _sendLogPayload(0x1c, 0xc4);
    9882
            /// @solidity memory-safe-assembly
    9883
            assembly {
    9884
                mstore(0x00, m0)
    9885
                mstore(0x20, m1)
    9886
                mstore(0x40, m2)
    9887
                mstore(0x60, m3)
    9888
                mstore(0x80, m4)
    9889
                mstore(0xa0, m5)
    9890
                mstore(0xc0, m6)
    9891
            }
    9892
        }
    9893
    
                                                    
                                                
    9894
        function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    9895
            bytes32 m0;
    9896
            bytes32 m1;
    9897
            bytes32 m2;
    9898
            bytes32 m3;
    9899
            bytes32 m4;
    9900
            bytes32 m5;
    9901
            bytes32 m6;
    9902
            bytes32 m7;
    9903
            bytes32 m8;
    9904
            /// @solidity memory-safe-assembly
    9905
            assembly {
    9906
                function writeString(pos, w) {
    9907
                    let length := 0
    9908
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9909
                    mstore(pos, length)
    9910
                    let shift := sub(256, shl(3, length))
    9911
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9912
                }
    9913
                m0 := mload(0x00)
    9914
                m1 := mload(0x20)
    9915
                m2 := mload(0x40)
    9916
                m3 := mload(0x60)
    9917
                m4 := mload(0x80)
    9918
                m5 := mload(0xa0)
    9919
                m6 := mload(0xc0)
    9920
                m7 := mload(0xe0)
    9921
                m8 := mload(0x100)
    9922
                // Selector of `log(uint256,uint256,string,string)`.
    9923
                mstore(0x00, 0x27d8afd2)
    9924
                mstore(0x20, p0)
    9925
                mstore(0x40, p1)
    9926
                mstore(0x60, 0x80)
    9927
                mstore(0x80, 0xc0)
    9928
                writeString(0xa0, p2)
    9929
                writeString(0xe0, p3)
    9930
            }
    9931
            _sendLogPayload(0x1c, 0x104);
    9932
            /// @solidity memory-safe-assembly
    9933
            assembly {
    9934
                mstore(0x00, m0)
    9935
                mstore(0x20, m1)
    9936
                mstore(0x40, m2)
    9937
                mstore(0x60, m3)
    9938
                mstore(0x80, m4)
    9939
                mstore(0xa0, m5)
    9940
                mstore(0xc0, m6)
    9941
                mstore(0xe0, m7)
    9942
                mstore(0x100, m8)
    9943
            }
    9944
        }
    9945
    
                                                    
                                                
    9946
        function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {
    9947
            bytes32 m0;
    9948
            bytes32 m1;
    9949
            bytes32 m2;
    9950
            bytes32 m3;
    9951
            bytes32 m4;
    9952
            bytes32 m5;
    9953
            bytes32 m6;
    9954
            /// @solidity memory-safe-assembly
    9955
            assembly {
    9956
                function writeString(pos, w) {
    9957
                    let length := 0
    9958
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9959
                    mstore(pos, length)
    9960
                    let shift := sub(256, shl(3, length))
    9961
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9962
                }
    9963
                m0 := mload(0x00)
    9964
                m1 := mload(0x20)
    9965
                m2 := mload(0x40)
    9966
                m3 := mload(0x60)
    9967
                m4 := mload(0x80)
    9968
                m5 := mload(0xa0)
    9969
                m6 := mload(0xc0)
    9970
                // Selector of `log(uint256,string,address,address)`.
    9971
                mstore(0x00, 0x6168ed61)
    9972
                mstore(0x20, p0)
    9973
                mstore(0x40, 0x80)
    9974
                mstore(0x60, p2)
    9975
                mstore(0x80, p3)
    9976
                writeString(0xa0, p1)
    9977
            }
    9978
            _sendLogPayload(0x1c, 0xc4);
    9979
            /// @solidity memory-safe-assembly
    9980
            assembly {
    9981
                mstore(0x00, m0)
    9982
                mstore(0x20, m1)
    9983
                mstore(0x40, m2)
    9984
                mstore(0x60, m3)
    9985
                mstore(0x80, m4)
    9986
                mstore(0xa0, m5)
    9987
                mstore(0xc0, m6)
    9988
            }
    9989
        }
    9990
    
                                                    
                                                
    9991
        function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {
    9992
            bytes32 m0;
    9993
            bytes32 m1;
    9994
            bytes32 m2;
    9995
            bytes32 m3;
    9996
            bytes32 m4;
    9997
            bytes32 m5;
    9998
            bytes32 m6;
    9999
            /// @solidity memory-safe-assembly
    10000
            assembly {
    10001
                function writeString(pos, w) {
    10002
                    let length := 0
    10003
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10004
                    mstore(pos, length)
    10005
                    let shift := sub(256, shl(3, length))
    10006
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10007
                }
    10008
                m0 := mload(0x00)
    10009
                m1 := mload(0x20)
    10010
                m2 := mload(0x40)
    10011
                m3 := mload(0x60)
    10012
                m4 := mload(0x80)
    10013
                m5 := mload(0xa0)
    10014
                m6 := mload(0xc0)
    10015
                // Selector of `log(uint256,string,address,bool)`.
    10016
                mstore(0x00, 0x90c30a56)
    10017
                mstore(0x20, p0)
    10018
                mstore(0x40, 0x80)
    10019
                mstore(0x60, p2)
    10020
                mstore(0x80, p3)
    10021
                writeString(0xa0, p1)
    10022
            }
    10023
            _sendLogPayload(0x1c, 0xc4);
    10024
            /// @solidity memory-safe-assembly
    10025
            assembly {
    10026
                mstore(0x00, m0)
    10027
                mstore(0x20, m1)
    10028
                mstore(0x40, m2)
    10029
                mstore(0x60, m3)
    10030
                mstore(0x80, m4)
    10031
                mstore(0xa0, m5)
    10032
                mstore(0xc0, m6)
    10033
            }
    10034
        }
    10035
    
                                                    
                                                
    10036
        function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    10037
            bytes32 m0;
    10038
            bytes32 m1;
    10039
            bytes32 m2;
    10040
            bytes32 m3;
    10041
            bytes32 m4;
    10042
            bytes32 m5;
    10043
            bytes32 m6;
    10044
            /// @solidity memory-safe-assembly
    10045
            assembly {
    10046
                function writeString(pos, w) {
    10047
                    let length := 0
    10048
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10049
                    mstore(pos, length)
    10050
                    let shift := sub(256, shl(3, length))
    10051
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10052
                }
    10053
                m0 := mload(0x00)
    10054
                m1 := mload(0x20)
    10055
                m2 := mload(0x40)
    10056
                m3 := mload(0x60)
    10057
                m4 := mload(0x80)
    10058
                m5 := mload(0xa0)
    10059
                m6 := mload(0xc0)
    10060
                // Selector of `log(uint256,string,address,uint256)`.
    10061
                mstore(0x00, 0xe8d3018d)
    10062
                mstore(0x20, p0)
    10063
                mstore(0x40, 0x80)
    10064
                mstore(0x60, p2)
    10065
                mstore(0x80, p3)
    10066
                writeString(0xa0, p1)
    10067
            }
    10068
            _sendLogPayload(0x1c, 0xc4);
    10069
            /// @solidity memory-safe-assembly
    10070
            assembly {
    10071
                mstore(0x00, m0)
    10072
                mstore(0x20, m1)
    10073
                mstore(0x40, m2)
    10074
                mstore(0x60, m3)
    10075
                mstore(0x80, m4)
    10076
                mstore(0xa0, m5)
    10077
                mstore(0xc0, m6)
    10078
            }
    10079
        }
    10080
    
                                                    
                                                
    10081
        function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    10082
            bytes32 m0;
    10083
            bytes32 m1;
    10084
            bytes32 m2;
    10085
            bytes32 m3;
    10086
            bytes32 m4;
    10087
            bytes32 m5;
    10088
            bytes32 m6;
    10089
            bytes32 m7;
    10090
            bytes32 m8;
    10091
            /// @solidity memory-safe-assembly
    10092
            assembly {
    10093
                function writeString(pos, w) {
    10094
                    let length := 0
    10095
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10096
                    mstore(pos, length)
    10097
                    let shift := sub(256, shl(3, length))
    10098
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10099
                }
    10100
                m0 := mload(0x00)
    10101
                m1 := mload(0x20)
    10102
                m2 := mload(0x40)
    10103
                m3 := mload(0x60)
    10104
                m4 := mload(0x80)
    10105
                m5 := mload(0xa0)
    10106
                m6 := mload(0xc0)
    10107
                m7 := mload(0xe0)
    10108
                m8 := mload(0x100)
    10109
                // Selector of `log(uint256,string,address,string)`.
    10110
                mstore(0x00, 0x9c3adfa1)
    10111
                mstore(0x20, p0)
    10112
                mstore(0x40, 0x80)
    10113
                mstore(0x60, p2)
    10114
                mstore(0x80, 0xc0)
    10115
                writeString(0xa0, p1)
    10116
                writeString(0xe0, p3)
    10117
            }
    10118
            _sendLogPayload(0x1c, 0x104);
    10119
            /// @solidity memory-safe-assembly
    10120
            assembly {
    10121
                mstore(0x00, m0)
    10122
                mstore(0x20, m1)
    10123
                mstore(0x40, m2)
    10124
                mstore(0x60, m3)
    10125
                mstore(0x80, m4)
    10126
                mstore(0xa0, m5)
    10127
                mstore(0xc0, m6)
    10128
                mstore(0xe0, m7)
    10129
                mstore(0x100, m8)
    10130
            }
    10131
        }
    10132
    
                                                    
                                                
    10133
        function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {
    10134
            bytes32 m0;
    10135
            bytes32 m1;
    10136
            bytes32 m2;
    10137
            bytes32 m3;
    10138
            bytes32 m4;
    10139
            bytes32 m5;
    10140
            bytes32 m6;
    10141
            /// @solidity memory-safe-assembly
    10142
            assembly {
    10143
                function writeString(pos, w) {
    10144
                    let length := 0
    10145
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10146
                    mstore(pos, length)
    10147
                    let shift := sub(256, shl(3, length))
    10148
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10149
                }
    10150
                m0 := mload(0x00)
    10151
                m1 := mload(0x20)
    10152
                m2 := mload(0x40)
    10153
                m3 := mload(0x60)
    10154
                m4 := mload(0x80)
    10155
                m5 := mload(0xa0)
    10156
                m6 := mload(0xc0)
    10157
                // Selector of `log(uint256,string,bool,address)`.
    10158
                mstore(0x00, 0xae2ec581)
    10159
                mstore(0x20, p0)
    10160
                mstore(0x40, 0x80)
    10161
                mstore(0x60, p2)
    10162
                mstore(0x80, p3)
    10163
                writeString(0xa0, p1)
    10164
            }
    10165
            _sendLogPayload(0x1c, 0xc4);
    10166
            /// @solidity memory-safe-assembly
    10167
            assembly {
    10168
                mstore(0x00, m0)
    10169
                mstore(0x20, m1)
    10170
                mstore(0x40, m2)
    10171
                mstore(0x60, m3)
    10172
                mstore(0x80, m4)
    10173
                mstore(0xa0, m5)
    10174
                mstore(0xc0, m6)
    10175
            }
    10176
        }
    10177
    
                                                    
                                                
    10178
        function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {
    10179
            bytes32 m0;
    10180
            bytes32 m1;
    10181
            bytes32 m2;
    10182
            bytes32 m3;
    10183
            bytes32 m4;
    10184
            bytes32 m5;
    10185
            bytes32 m6;
    10186
            /// @solidity memory-safe-assembly
    10187
            assembly {
    10188
                function writeString(pos, w) {
    10189
                    let length := 0
    10190
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10191
                    mstore(pos, length)
    10192
                    let shift := sub(256, shl(3, length))
    10193
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10194
                }
    10195
                m0 := mload(0x00)
    10196
                m1 := mload(0x20)
    10197
                m2 := mload(0x40)
    10198
                m3 := mload(0x60)
    10199
                m4 := mload(0x80)
    10200
                m5 := mload(0xa0)
    10201
                m6 := mload(0xc0)
    10202
                // Selector of `log(uint256,string,bool,bool)`.
    10203
                mstore(0x00, 0xba535d9c)
    10204
                mstore(0x20, p0)
    10205
                mstore(0x40, 0x80)
    10206
                mstore(0x60, p2)
    10207
                mstore(0x80, p3)
    10208
                writeString(0xa0, p1)
    10209
            }
    10210
            _sendLogPayload(0x1c, 0xc4);
    10211
            /// @solidity memory-safe-assembly
    10212
            assembly {
    10213
                mstore(0x00, m0)
    10214
                mstore(0x20, m1)
    10215
                mstore(0x40, m2)
    10216
                mstore(0x60, m3)
    10217
                mstore(0x80, m4)
    10218
                mstore(0xa0, m5)
    10219
                mstore(0xc0, m6)
    10220
            }
    10221
        }
    10222
    
                                                    
                                                
    10223
        function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    10224
            bytes32 m0;
    10225
            bytes32 m1;
    10226
            bytes32 m2;
    10227
            bytes32 m3;
    10228
            bytes32 m4;
    10229
            bytes32 m5;
    10230
            bytes32 m6;
    10231
            /// @solidity memory-safe-assembly
    10232
            assembly {
    10233
                function writeString(pos, w) {
    10234
                    let length := 0
    10235
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10236
                    mstore(pos, length)
    10237
                    let shift := sub(256, shl(3, length))
    10238
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10239
                }
    10240
                m0 := mload(0x00)
    10241
                m1 := mload(0x20)
    10242
                m2 := mload(0x40)
    10243
                m3 := mload(0x60)
    10244
                m4 := mload(0x80)
    10245
                m5 := mload(0xa0)
    10246
                m6 := mload(0xc0)
    10247
                // Selector of `log(uint256,string,bool,uint256)`.
    10248
                mstore(0x00, 0xcf009880)
    10249
                mstore(0x20, p0)
    10250
                mstore(0x40, 0x80)
    10251
                mstore(0x60, p2)
    10252
                mstore(0x80, p3)
    10253
                writeString(0xa0, p1)
    10254
            }
    10255
            _sendLogPayload(0x1c, 0xc4);
    10256
            /// @solidity memory-safe-assembly
    10257
            assembly {
    10258
                mstore(0x00, m0)
    10259
                mstore(0x20, m1)
    10260
                mstore(0x40, m2)
    10261
                mstore(0x60, m3)
    10262
                mstore(0x80, m4)
    10263
                mstore(0xa0, m5)
    10264
                mstore(0xc0, m6)
    10265
            }
    10266
        }
    10267
    
                                                    
                                                
    10268
        function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    10269
            bytes32 m0;
    10270
            bytes32 m1;
    10271
            bytes32 m2;
    10272
            bytes32 m3;
    10273
            bytes32 m4;
    10274
            bytes32 m5;
    10275
            bytes32 m6;
    10276
            bytes32 m7;
    10277
            bytes32 m8;
    10278
            /// @solidity memory-safe-assembly
    10279
            assembly {
    10280
                function writeString(pos, w) {
    10281
                    let length := 0
    10282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10283
                    mstore(pos, length)
    10284
                    let shift := sub(256, shl(3, length))
    10285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10286
                }
    10287
                m0 := mload(0x00)
    10288
                m1 := mload(0x20)
    10289
                m2 := mload(0x40)
    10290
                m3 := mload(0x60)
    10291
                m4 := mload(0x80)
    10292
                m5 := mload(0xa0)
    10293
                m6 := mload(0xc0)
    10294
                m7 := mload(0xe0)
    10295
                m8 := mload(0x100)
    10296
                // Selector of `log(uint256,string,bool,string)`.
    10297
                mstore(0x00, 0xd2d423cd)
    10298
                mstore(0x20, p0)
    10299
                mstore(0x40, 0x80)
    10300
                mstore(0x60, p2)
    10301
                mstore(0x80, 0xc0)
    10302
                writeString(0xa0, p1)
    10303
                writeString(0xe0, p3)
    10304
            }
    10305
            _sendLogPayload(0x1c, 0x104);
    10306
            /// @solidity memory-safe-assembly
    10307
            assembly {
    10308
                mstore(0x00, m0)
    10309
                mstore(0x20, m1)
    10310
                mstore(0x40, m2)
    10311
                mstore(0x60, m3)
    10312
                mstore(0x80, m4)
    10313
                mstore(0xa0, m5)
    10314
                mstore(0xc0, m6)
    10315
                mstore(0xe0, m7)
    10316
                mstore(0x100, m8)
    10317
            }
    10318
        }
    10319
    
                                                    
                                                
    10320
        function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    10321
            bytes32 m0;
    10322
            bytes32 m1;
    10323
            bytes32 m2;
    10324
            bytes32 m3;
    10325
            bytes32 m4;
    10326
            bytes32 m5;
    10327
            bytes32 m6;
    10328
            /// @solidity memory-safe-assembly
    10329
            assembly {
    10330
                function writeString(pos, w) {
    10331
                    let length := 0
    10332
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10333
                    mstore(pos, length)
    10334
                    let shift := sub(256, shl(3, length))
    10335
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10336
                }
    10337
                m0 := mload(0x00)
    10338
                m1 := mload(0x20)
    10339
                m2 := mload(0x40)
    10340
                m3 := mload(0x60)
    10341
                m4 := mload(0x80)
    10342
                m5 := mload(0xa0)
    10343
                m6 := mload(0xc0)
    10344
                // Selector of `log(uint256,string,uint256,address)`.
    10345
                mstore(0x00, 0x3b2279b4)
    10346
                mstore(0x20, p0)
    10347
                mstore(0x40, 0x80)
    10348
                mstore(0x60, p2)
    10349
                mstore(0x80, p3)
    10350
                writeString(0xa0, p1)
    10351
            }
    10352
            _sendLogPayload(0x1c, 0xc4);
    10353
            /// @solidity memory-safe-assembly
    10354
            assembly {
    10355
                mstore(0x00, m0)
    10356
                mstore(0x20, m1)
    10357
                mstore(0x40, m2)
    10358
                mstore(0x60, m3)
    10359
                mstore(0x80, m4)
    10360
                mstore(0xa0, m5)
    10361
                mstore(0xc0, m6)
    10362
            }
    10363
        }
    10364
    
                                                    
                                                
    10365
        function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    10366
            bytes32 m0;
    10367
            bytes32 m1;
    10368
            bytes32 m2;
    10369
            bytes32 m3;
    10370
            bytes32 m4;
    10371
            bytes32 m5;
    10372
            bytes32 m6;
    10373
            /// @solidity memory-safe-assembly
    10374
            assembly {
    10375
                function writeString(pos, w) {
    10376
                    let length := 0
    10377
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10378
                    mstore(pos, length)
    10379
                    let shift := sub(256, shl(3, length))
    10380
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10381
                }
    10382
                m0 := mload(0x00)
    10383
                m1 := mload(0x20)
    10384
                m2 := mload(0x40)
    10385
                m3 := mload(0x60)
    10386
                m4 := mload(0x80)
    10387
                m5 := mload(0xa0)
    10388
                m6 := mload(0xc0)
    10389
                // Selector of `log(uint256,string,uint256,bool)`.
    10390
                mstore(0x00, 0x691a8f74)
    10391
                mstore(0x20, p0)
    10392
                mstore(0x40, 0x80)
    10393
                mstore(0x60, p2)
    10394
                mstore(0x80, p3)
    10395
                writeString(0xa0, p1)
    10396
            }
    10397
            _sendLogPayload(0x1c, 0xc4);
    10398
            /// @solidity memory-safe-assembly
    10399
            assembly {
    10400
                mstore(0x00, m0)
    10401
                mstore(0x20, m1)
    10402
                mstore(0x40, m2)
    10403
                mstore(0x60, m3)
    10404
                mstore(0x80, m4)
    10405
                mstore(0xa0, m5)
    10406
                mstore(0xc0, m6)
    10407
            }
    10408
        }
    10409
    
                                                    
                                                
    10410
        function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    10411
            bytes32 m0;
    10412
            bytes32 m1;
    10413
            bytes32 m2;
    10414
            bytes32 m3;
    10415
            bytes32 m4;
    10416
            bytes32 m5;
    10417
            bytes32 m6;
    10418
            /// @solidity memory-safe-assembly
    10419
            assembly {
    10420
                function writeString(pos, w) {
    10421
                    let length := 0
    10422
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10423
                    mstore(pos, length)
    10424
                    let shift := sub(256, shl(3, length))
    10425
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10426
                }
    10427
                m0 := mload(0x00)
    10428
                m1 := mload(0x20)
    10429
                m2 := mload(0x40)
    10430
                m3 := mload(0x60)
    10431
                m4 := mload(0x80)
    10432
                m5 := mload(0xa0)
    10433
                m6 := mload(0xc0)
    10434
                // Selector of `log(uint256,string,uint256,uint256)`.
    10435
                mstore(0x00, 0x82c25b74)
    10436
                mstore(0x20, p0)
    10437
                mstore(0x40, 0x80)
    10438
                mstore(0x60, p2)
    10439
                mstore(0x80, p3)
    10440
                writeString(0xa0, p1)
    10441
            }
    10442
            _sendLogPayload(0x1c, 0xc4);
    10443
            /// @solidity memory-safe-assembly
    10444
            assembly {
    10445
                mstore(0x00, m0)
    10446
                mstore(0x20, m1)
    10447
                mstore(0x40, m2)
    10448
                mstore(0x60, m3)
    10449
                mstore(0x80, m4)
    10450
                mstore(0xa0, m5)
    10451
                mstore(0xc0, m6)
    10452
            }
    10453
        }
    10454
    
                                                    
                                                
    10455
        function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    10456
            bytes32 m0;
    10457
            bytes32 m1;
    10458
            bytes32 m2;
    10459
            bytes32 m3;
    10460
            bytes32 m4;
    10461
            bytes32 m5;
    10462
            bytes32 m6;
    10463
            bytes32 m7;
    10464
            bytes32 m8;
    10465
            /// @solidity memory-safe-assembly
    10466
            assembly {
    10467
                function writeString(pos, w) {
    10468
                    let length := 0
    10469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10470
                    mstore(pos, length)
    10471
                    let shift := sub(256, shl(3, length))
    10472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10473
                }
    10474
                m0 := mload(0x00)
    10475
                m1 := mload(0x20)
    10476
                m2 := mload(0x40)
    10477
                m3 := mload(0x60)
    10478
                m4 := mload(0x80)
    10479
                m5 := mload(0xa0)
    10480
                m6 := mload(0xc0)
    10481
                m7 := mload(0xe0)
    10482
                m8 := mload(0x100)
    10483
                // Selector of `log(uint256,string,uint256,string)`.
    10484
                mstore(0x00, 0xb7b914ca)
    10485
                mstore(0x20, p0)
    10486
                mstore(0x40, 0x80)
    10487
                mstore(0x60, p2)
    10488
                mstore(0x80, 0xc0)
    10489
                writeString(0xa0, p1)
    10490
                writeString(0xe0, p3)
    10491
            }
    10492
            _sendLogPayload(0x1c, 0x104);
    10493
            /// @solidity memory-safe-assembly
    10494
            assembly {
    10495
                mstore(0x00, m0)
    10496
                mstore(0x20, m1)
    10497
                mstore(0x40, m2)
    10498
                mstore(0x60, m3)
    10499
                mstore(0x80, m4)
    10500
                mstore(0xa0, m5)
    10501
                mstore(0xc0, m6)
    10502
                mstore(0xe0, m7)
    10503
                mstore(0x100, m8)
    10504
            }
    10505
        }
    10506
    
                                                    
                                                
    10507
        function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    10508
            bytes32 m0;
    10509
            bytes32 m1;
    10510
            bytes32 m2;
    10511
            bytes32 m3;
    10512
            bytes32 m4;
    10513
            bytes32 m5;
    10514
            bytes32 m6;
    10515
            bytes32 m7;
    10516
            bytes32 m8;
    10517
            /// @solidity memory-safe-assembly
    10518
            assembly {
    10519
                function writeString(pos, w) {
    10520
                    let length := 0
    10521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10522
                    mstore(pos, length)
    10523
                    let shift := sub(256, shl(3, length))
    10524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10525
                }
    10526
                m0 := mload(0x00)
    10527
                m1 := mload(0x20)
    10528
                m2 := mload(0x40)
    10529
                m3 := mload(0x60)
    10530
                m4 := mload(0x80)
    10531
                m5 := mload(0xa0)
    10532
                m6 := mload(0xc0)
    10533
                m7 := mload(0xe0)
    10534
                m8 := mload(0x100)
    10535
                // Selector of `log(uint256,string,string,address)`.
    10536
                mstore(0x00, 0xd583c602)
    10537
                mstore(0x20, p0)
    10538
                mstore(0x40, 0x80)
    10539
                mstore(0x60, 0xc0)
    10540
                mstore(0x80, p3)
    10541
                writeString(0xa0, p1)
    10542
                writeString(0xe0, p2)
    10543
            }
    10544
            _sendLogPayload(0x1c, 0x104);
    10545
            /// @solidity memory-safe-assembly
    10546
            assembly {
    10547
                mstore(0x00, m0)
    10548
                mstore(0x20, m1)
    10549
                mstore(0x40, m2)
    10550
                mstore(0x60, m3)
    10551
                mstore(0x80, m4)
    10552
                mstore(0xa0, m5)
    10553
                mstore(0xc0, m6)
    10554
                mstore(0xe0, m7)
    10555
                mstore(0x100, m8)
    10556
            }
    10557
        }
    10558
    
                                                    
                                                
    10559
        function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    10560
            bytes32 m0;
    10561
            bytes32 m1;
    10562
            bytes32 m2;
    10563
            bytes32 m3;
    10564
            bytes32 m4;
    10565
            bytes32 m5;
    10566
            bytes32 m6;
    10567
            bytes32 m7;
    10568
            bytes32 m8;
    10569
            /// @solidity memory-safe-assembly
    10570
            assembly {
    10571
                function writeString(pos, w) {
    10572
                    let length := 0
    10573
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10574
                    mstore(pos, length)
    10575
                    let shift := sub(256, shl(3, length))
    10576
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10577
                }
    10578
                m0 := mload(0x00)
    10579
                m1 := mload(0x20)
    10580
                m2 := mload(0x40)
    10581
                m3 := mload(0x60)
    10582
                m4 := mload(0x80)
    10583
                m5 := mload(0xa0)
    10584
                m6 := mload(0xc0)
    10585
                m7 := mload(0xe0)
    10586
                m8 := mload(0x100)
    10587
                // Selector of `log(uint256,string,string,bool)`.
    10588
                mstore(0x00, 0xb3a6b6bd)
    10589
                mstore(0x20, p0)
    10590
                mstore(0x40, 0x80)
    10591
                mstore(0x60, 0xc0)
    10592
                mstore(0x80, p3)
    10593
                writeString(0xa0, p1)
    10594
                writeString(0xe0, p2)
    10595
            }
    10596
            _sendLogPayload(0x1c, 0x104);
    10597
            /// @solidity memory-safe-assembly
    10598
            assembly {
    10599
                mstore(0x00, m0)
    10600
                mstore(0x20, m1)
    10601
                mstore(0x40, m2)
    10602
                mstore(0x60, m3)
    10603
                mstore(0x80, m4)
    10604
                mstore(0xa0, m5)
    10605
                mstore(0xc0, m6)
    10606
                mstore(0xe0, m7)
    10607
                mstore(0x100, m8)
    10608
            }
    10609
        }
    10610
    
                                                    
                                                
    10611
        function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    10612
            bytes32 m0;
    10613
            bytes32 m1;
    10614
            bytes32 m2;
    10615
            bytes32 m3;
    10616
            bytes32 m4;
    10617
            bytes32 m5;
    10618
            bytes32 m6;
    10619
            bytes32 m7;
    10620
            bytes32 m8;
    10621
            /// @solidity memory-safe-assembly
    10622
            assembly {
    10623
                function writeString(pos, w) {
    10624
                    let length := 0
    10625
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10626
                    mstore(pos, length)
    10627
                    let shift := sub(256, shl(3, length))
    10628
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10629
                }
    10630
                m0 := mload(0x00)
    10631
                m1 := mload(0x20)
    10632
                m2 := mload(0x40)
    10633
                m3 := mload(0x60)
    10634
                m4 := mload(0x80)
    10635
                m5 := mload(0xa0)
    10636
                m6 := mload(0xc0)
    10637
                m7 := mload(0xe0)
    10638
                m8 := mload(0x100)
    10639
                // Selector of `log(uint256,string,string,uint256)`.
    10640
                mstore(0x00, 0xb028c9bd)
    10641
                mstore(0x20, p0)
    10642
                mstore(0x40, 0x80)
    10643
                mstore(0x60, 0xc0)
    10644
                mstore(0x80, p3)
    10645
                writeString(0xa0, p1)
    10646
                writeString(0xe0, p2)
    10647
            }
    10648
            _sendLogPayload(0x1c, 0x104);
    10649
            /// @solidity memory-safe-assembly
    10650
            assembly {
    10651
                mstore(0x00, m0)
    10652
                mstore(0x20, m1)
    10653
                mstore(0x40, m2)
    10654
                mstore(0x60, m3)
    10655
                mstore(0x80, m4)
    10656
                mstore(0xa0, m5)
    10657
                mstore(0xc0, m6)
    10658
                mstore(0xe0, m7)
    10659
                mstore(0x100, m8)
    10660
            }
    10661
        }
    10662
    
                                                    
                                                
    10663
        function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    10664
            bytes32 m0;
    10665
            bytes32 m1;
    10666
            bytes32 m2;
    10667
            bytes32 m3;
    10668
            bytes32 m4;
    10669
            bytes32 m5;
    10670
            bytes32 m6;
    10671
            bytes32 m7;
    10672
            bytes32 m8;
    10673
            bytes32 m9;
    10674
            bytes32 m10;
    10675
            /// @solidity memory-safe-assembly
    10676
            assembly {
    10677
                function writeString(pos, w) {
    10678
                    let length := 0
    10679
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10680
                    mstore(pos, length)
    10681
                    let shift := sub(256, shl(3, length))
    10682
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10683
                }
    10684
                m0 := mload(0x00)
    10685
                m1 := mload(0x20)
    10686
                m2 := mload(0x40)
    10687
                m3 := mload(0x60)
    10688
                m4 := mload(0x80)
    10689
                m5 := mload(0xa0)
    10690
                m6 := mload(0xc0)
    10691
                m7 := mload(0xe0)
    10692
                m8 := mload(0x100)
    10693
                m9 := mload(0x120)
    10694
                m10 := mload(0x140)
    10695
                // Selector of `log(uint256,string,string,string)`.
    10696
                mstore(0x00, 0x21ad0683)
    10697
                mstore(0x20, p0)
    10698
                mstore(0x40, 0x80)
    10699
                mstore(0x60, 0xc0)
    10700
                mstore(0x80, 0x100)
    10701
                writeString(0xa0, p1)
    10702
                writeString(0xe0, p2)
    10703
                writeString(0x120, p3)
    10704
            }
    10705
            _sendLogPayload(0x1c, 0x144);
    10706
            /// @solidity memory-safe-assembly
    10707
            assembly {
    10708
                mstore(0x00, m0)
    10709
                mstore(0x20, m1)
    10710
                mstore(0x40, m2)
    10711
                mstore(0x60, m3)
    10712
                mstore(0x80, m4)
    10713
                mstore(0xa0, m5)
    10714
                mstore(0xc0, m6)
    10715
                mstore(0xe0, m7)
    10716
                mstore(0x100, m8)
    10717
                mstore(0x120, m9)
    10718
                mstore(0x140, m10)
    10719
            }
    10720
        }
    10721
    
                                                    
                                                
    10722
        function log(bytes32 p0, address p1, address p2, address p3) internal pure {
    10723
            bytes32 m0;
    10724
            bytes32 m1;
    10725
            bytes32 m2;
    10726
            bytes32 m3;
    10727
            bytes32 m4;
    10728
            bytes32 m5;
    10729
            bytes32 m6;
    10730
            /// @solidity memory-safe-assembly
    10731
            assembly {
    10732
                function writeString(pos, w) {
    10733
                    let length := 0
    10734
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10735
                    mstore(pos, length)
    10736
                    let shift := sub(256, shl(3, length))
    10737
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10738
                }
    10739
                m0 := mload(0x00)
    10740
                m1 := mload(0x20)
    10741
                m2 := mload(0x40)
    10742
                m3 := mload(0x60)
    10743
                m4 := mload(0x80)
    10744
                m5 := mload(0xa0)
    10745
                m6 := mload(0xc0)
    10746
                // Selector of `log(string,address,address,address)`.
    10747
                mstore(0x00, 0xed8f28f6)
    10748
                mstore(0x20, 0x80)
    10749
                mstore(0x40, p1)
    10750
                mstore(0x60, p2)
    10751
                mstore(0x80, p3)
    10752
                writeString(0xa0, p0)
    10753
            }
    10754
            _sendLogPayload(0x1c, 0xc4);
    10755
            /// @solidity memory-safe-assembly
    10756
            assembly {
    10757
                mstore(0x00, m0)
    10758
                mstore(0x20, m1)
    10759
                mstore(0x40, m2)
    10760
                mstore(0x60, m3)
    10761
                mstore(0x80, m4)
    10762
                mstore(0xa0, m5)
    10763
                mstore(0xc0, m6)
    10764
            }
    10765
        }
    10766
    
                                                    
                                                
    10767
        function log(bytes32 p0, address p1, address p2, bool p3) internal pure {
    10768
            bytes32 m0;
    10769
            bytes32 m1;
    10770
            bytes32 m2;
    10771
            bytes32 m3;
    10772
            bytes32 m4;
    10773
            bytes32 m5;
    10774
            bytes32 m6;
    10775
            /// @solidity memory-safe-assembly
    10776
            assembly {
    10777
                function writeString(pos, w) {
    10778
                    let length := 0
    10779
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10780
                    mstore(pos, length)
    10781
                    let shift := sub(256, shl(3, length))
    10782
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10783
                }
    10784
                m0 := mload(0x00)
    10785
                m1 := mload(0x20)
    10786
                m2 := mload(0x40)
    10787
                m3 := mload(0x60)
    10788
                m4 := mload(0x80)
    10789
                m5 := mload(0xa0)
    10790
                m6 := mload(0xc0)
    10791
                // Selector of `log(string,address,address,bool)`.
    10792
                mstore(0x00, 0xb59dbd60)
    10793
                mstore(0x20, 0x80)
    10794
                mstore(0x40, p1)
    10795
                mstore(0x60, p2)
    10796
                mstore(0x80, p3)
    10797
                writeString(0xa0, p0)
    10798
            }
    10799
            _sendLogPayload(0x1c, 0xc4);
    10800
            /// @solidity memory-safe-assembly
    10801
            assembly {
    10802
                mstore(0x00, m0)
    10803
                mstore(0x20, m1)
    10804
                mstore(0x40, m2)
    10805
                mstore(0x60, m3)
    10806
                mstore(0x80, m4)
    10807
                mstore(0xa0, m5)
    10808
                mstore(0xc0, m6)
    10809
            }
    10810
        }
    10811
    
                                                    
                                                
    10812
        function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {
    10813
            bytes32 m0;
    10814
            bytes32 m1;
    10815
            bytes32 m2;
    10816
            bytes32 m3;
    10817
            bytes32 m4;
    10818
            bytes32 m5;
    10819
            bytes32 m6;
    10820
            /// @solidity memory-safe-assembly
    10821
            assembly {
    10822
                function writeString(pos, w) {
    10823
                    let length := 0
    10824
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10825
                    mstore(pos, length)
    10826
                    let shift := sub(256, shl(3, length))
    10827
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10828
                }
    10829
                m0 := mload(0x00)
    10830
                m1 := mload(0x20)
    10831
                m2 := mload(0x40)
    10832
                m3 := mload(0x60)
    10833
                m4 := mload(0x80)
    10834
                m5 := mload(0xa0)
    10835
                m6 := mload(0xc0)
    10836
                // Selector of `log(string,address,address,uint256)`.
    10837
                mstore(0x00, 0x8ef3f399)
    10838
                mstore(0x20, 0x80)
    10839
                mstore(0x40, p1)
    10840
                mstore(0x60, p2)
    10841
                mstore(0x80, p3)
    10842
                writeString(0xa0, p0)
    10843
            }
    10844
            _sendLogPayload(0x1c, 0xc4);
    10845
            /// @solidity memory-safe-assembly
    10846
            assembly {
    10847
                mstore(0x00, m0)
    10848
                mstore(0x20, m1)
    10849
                mstore(0x40, m2)
    10850
                mstore(0x60, m3)
    10851
                mstore(0x80, m4)
    10852
                mstore(0xa0, m5)
    10853
                mstore(0xc0, m6)
    10854
            }
    10855
        }
    10856
    
                                                    
                                                
    10857
        function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {
    10858
            bytes32 m0;
    10859
            bytes32 m1;
    10860
            bytes32 m2;
    10861
            bytes32 m3;
    10862
            bytes32 m4;
    10863
            bytes32 m5;
    10864
            bytes32 m6;
    10865
            bytes32 m7;
    10866
            bytes32 m8;
    10867
            /// @solidity memory-safe-assembly
    10868
            assembly {
    10869
                function writeString(pos, w) {
    10870
                    let length := 0
    10871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10872
                    mstore(pos, length)
    10873
                    let shift := sub(256, shl(3, length))
    10874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10875
                }
    10876
                m0 := mload(0x00)
    10877
                m1 := mload(0x20)
    10878
                m2 := mload(0x40)
    10879
                m3 := mload(0x60)
    10880
                m4 := mload(0x80)
    10881
                m5 := mload(0xa0)
    10882
                m6 := mload(0xc0)
    10883
                m7 := mload(0xe0)
    10884
                m8 := mload(0x100)
    10885
                // Selector of `log(string,address,address,string)`.
    10886
                mstore(0x00, 0x800a1c67)
    10887
                mstore(0x20, 0x80)
    10888
                mstore(0x40, p1)
    10889
                mstore(0x60, p2)
    10890
                mstore(0x80, 0xc0)
    10891
                writeString(0xa0, p0)
    10892
                writeString(0xe0, p3)
    10893
            }
    10894
            _sendLogPayload(0x1c, 0x104);
    10895
            /// @solidity memory-safe-assembly
    10896
            assembly {
    10897
                mstore(0x00, m0)
    10898
                mstore(0x20, m1)
    10899
                mstore(0x40, m2)
    10900
                mstore(0x60, m3)
    10901
                mstore(0x80, m4)
    10902
                mstore(0xa0, m5)
    10903
                mstore(0xc0, m6)
    10904
                mstore(0xe0, m7)
    10905
                mstore(0x100, m8)
    10906
            }
    10907
        }
    10908
    
                                                    
                                                
    10909
        function log(bytes32 p0, address p1, bool p2, address p3) internal pure {
    10910
            bytes32 m0;
    10911
            bytes32 m1;
    10912
            bytes32 m2;
    10913
            bytes32 m3;
    10914
            bytes32 m4;
    10915
            bytes32 m5;
    10916
            bytes32 m6;
    10917
            /// @solidity memory-safe-assembly
    10918
            assembly {
    10919
                function writeString(pos, w) {
    10920
                    let length := 0
    10921
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10922
                    mstore(pos, length)
    10923
                    let shift := sub(256, shl(3, length))
    10924
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10925
                }
    10926
                m0 := mload(0x00)
    10927
                m1 := mload(0x20)
    10928
                m2 := mload(0x40)
    10929
                m3 := mload(0x60)
    10930
                m4 := mload(0x80)
    10931
                m5 := mload(0xa0)
    10932
                m6 := mload(0xc0)
    10933
                // Selector of `log(string,address,bool,address)`.
    10934
                mstore(0x00, 0x223603bd)
    10935
                mstore(0x20, 0x80)
    10936
                mstore(0x40, p1)
    10937
                mstore(0x60, p2)
    10938
                mstore(0x80, p3)
    10939
                writeString(0xa0, p0)
    10940
            }
    10941
            _sendLogPayload(0x1c, 0xc4);
    10942
            /// @solidity memory-safe-assembly
    10943
            assembly {
    10944
                mstore(0x00, m0)
    10945
                mstore(0x20, m1)
    10946
                mstore(0x40, m2)
    10947
                mstore(0x60, m3)
    10948
                mstore(0x80, m4)
    10949
                mstore(0xa0, m5)
    10950
                mstore(0xc0, m6)
    10951
            }
    10952
        }
    10953
    
                                                    
                                                
    10954
        function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {
    10955
            bytes32 m0;
    10956
            bytes32 m1;
    10957
            bytes32 m2;
    10958
            bytes32 m3;
    10959
            bytes32 m4;
    10960
            bytes32 m5;
    10961
            bytes32 m6;
    10962
            /// @solidity memory-safe-assembly
    10963
            assembly {
    10964
                function writeString(pos, w) {
    10965
                    let length := 0
    10966
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10967
                    mstore(pos, length)
    10968
                    let shift := sub(256, shl(3, length))
    10969
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10970
                }
    10971
                m0 := mload(0x00)
    10972
                m1 := mload(0x20)
    10973
                m2 := mload(0x40)
    10974
                m3 := mload(0x60)
    10975
                m4 := mload(0x80)
    10976
                m5 := mload(0xa0)
    10977
                m6 := mload(0xc0)
    10978
                // Selector of `log(string,address,bool,bool)`.
    10979
                mstore(0x00, 0x79884c2b)
    10980
                mstore(0x20, 0x80)
    10981
                mstore(0x40, p1)
    10982
                mstore(0x60, p2)
    10983
                mstore(0x80, p3)
    10984
                writeString(0xa0, p0)
    10985
            }
    10986
            _sendLogPayload(0x1c, 0xc4);
    10987
            /// @solidity memory-safe-assembly
    10988
            assembly {
    10989
                mstore(0x00, m0)
    10990
                mstore(0x20, m1)
    10991
                mstore(0x40, m2)
    10992
                mstore(0x60, m3)
    10993
                mstore(0x80, m4)
    10994
                mstore(0xa0, m5)
    10995
                mstore(0xc0, m6)
    10996
            }
    10997
        }
    10998
    
                                                    
                                                
    10999
        function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {
    11000
            bytes32 m0;
    11001
            bytes32 m1;
    11002
            bytes32 m2;
    11003
            bytes32 m3;
    11004
            bytes32 m4;
    11005
            bytes32 m5;
    11006
            bytes32 m6;
    11007
            /// @solidity memory-safe-assembly
    11008
            assembly {
    11009
                function writeString(pos, w) {
    11010
                    let length := 0
    11011
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11012
                    mstore(pos, length)
    11013
                    let shift := sub(256, shl(3, length))
    11014
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11015
                }
    11016
                m0 := mload(0x00)
    11017
                m1 := mload(0x20)
    11018
                m2 := mload(0x40)
    11019
                m3 := mload(0x60)
    11020
                m4 := mload(0x80)
    11021
                m5 := mload(0xa0)
    11022
                m6 := mload(0xc0)
    11023
                // Selector of `log(string,address,bool,uint256)`.
    11024
                mstore(0x00, 0x3e9f866a)
    11025
                mstore(0x20, 0x80)
    11026
                mstore(0x40, p1)
    11027
                mstore(0x60, p2)
    11028
                mstore(0x80, p3)
    11029
                writeString(0xa0, p0)
    11030
            }
    11031
            _sendLogPayload(0x1c, 0xc4);
    11032
            /// @solidity memory-safe-assembly
    11033
            assembly {
    11034
                mstore(0x00, m0)
    11035
                mstore(0x20, m1)
    11036
                mstore(0x40, m2)
    11037
                mstore(0x60, m3)
    11038
                mstore(0x80, m4)
    11039
                mstore(0xa0, m5)
    11040
                mstore(0xc0, m6)
    11041
            }
    11042
        }
    11043
    
                                                    
                                                
    11044
        function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {
    11045
            bytes32 m0;
    11046
            bytes32 m1;
    11047
            bytes32 m2;
    11048
            bytes32 m3;
    11049
            bytes32 m4;
    11050
            bytes32 m5;
    11051
            bytes32 m6;
    11052
            bytes32 m7;
    11053
            bytes32 m8;
    11054
            /// @solidity memory-safe-assembly
    11055
            assembly {
    11056
                function writeString(pos, w) {
    11057
                    let length := 0
    11058
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11059
                    mstore(pos, length)
    11060
                    let shift := sub(256, shl(3, length))
    11061
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11062
                }
    11063
                m0 := mload(0x00)
    11064
                m1 := mload(0x20)
    11065
                m2 := mload(0x40)
    11066
                m3 := mload(0x60)
    11067
                m4 := mload(0x80)
    11068
                m5 := mload(0xa0)
    11069
                m6 := mload(0xc0)
    11070
                m7 := mload(0xe0)
    11071
                m8 := mload(0x100)
    11072
                // Selector of `log(string,address,bool,string)`.
    11073
                mstore(0x00, 0x0454c079)
    11074
                mstore(0x20, 0x80)
    11075
                mstore(0x40, p1)
    11076
                mstore(0x60, p2)
    11077
                mstore(0x80, 0xc0)
    11078
                writeString(0xa0, p0)
    11079
                writeString(0xe0, p3)
    11080
            }
    11081
            _sendLogPayload(0x1c, 0x104);
    11082
            /// @solidity memory-safe-assembly
    11083
            assembly {
    11084
                mstore(0x00, m0)
    11085
                mstore(0x20, m1)
    11086
                mstore(0x40, m2)
    11087
                mstore(0x60, m3)
    11088
                mstore(0x80, m4)
    11089
                mstore(0xa0, m5)
    11090
                mstore(0xc0, m6)
    11091
                mstore(0xe0, m7)
    11092
                mstore(0x100, m8)
    11093
            }
    11094
        }
    11095
    
                                                    
                                                
    11096
        function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {
    11097
            bytes32 m0;
    11098
            bytes32 m1;
    11099
            bytes32 m2;
    11100
            bytes32 m3;
    11101
            bytes32 m4;
    11102
            bytes32 m5;
    11103
            bytes32 m6;
    11104
            /// @solidity memory-safe-assembly
    11105
            assembly {
    11106
                function writeString(pos, w) {
    11107
                    let length := 0
    11108
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11109
                    mstore(pos, length)
    11110
                    let shift := sub(256, shl(3, length))
    11111
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11112
                }
    11113
                m0 := mload(0x00)
    11114
                m1 := mload(0x20)
    11115
                m2 := mload(0x40)
    11116
                m3 := mload(0x60)
    11117
                m4 := mload(0x80)
    11118
                m5 := mload(0xa0)
    11119
                m6 := mload(0xc0)
    11120
                // Selector of `log(string,address,uint256,address)`.
    11121
                mstore(0x00, 0x63fb8bc5)
    11122
                mstore(0x20, 0x80)
    11123
                mstore(0x40, p1)
    11124
                mstore(0x60, p2)
    11125
                mstore(0x80, p3)
    11126
                writeString(0xa0, p0)
    11127
            }
    11128
            _sendLogPayload(0x1c, 0xc4);
    11129
            /// @solidity memory-safe-assembly
    11130
            assembly {
    11131
                mstore(0x00, m0)
    11132
                mstore(0x20, m1)
    11133
                mstore(0x40, m2)
    11134
                mstore(0x60, m3)
    11135
                mstore(0x80, m4)
    11136
                mstore(0xa0, m5)
    11137
                mstore(0xc0, m6)
    11138
            }
    11139
        }
    11140
    
                                                    
                                                
    11141
        function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {
    11142
            bytes32 m0;
    11143
            bytes32 m1;
    11144
            bytes32 m2;
    11145
            bytes32 m3;
    11146
            bytes32 m4;
    11147
            bytes32 m5;
    11148
            bytes32 m6;
    11149
            /// @solidity memory-safe-assembly
    11150
            assembly {
    11151
                function writeString(pos, w) {
    11152
                    let length := 0
    11153
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11154
                    mstore(pos, length)
    11155
                    let shift := sub(256, shl(3, length))
    11156
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11157
                }
    11158
                m0 := mload(0x00)
    11159
                m1 := mload(0x20)
    11160
                m2 := mload(0x40)
    11161
                m3 := mload(0x60)
    11162
                m4 := mload(0x80)
    11163
                m5 := mload(0xa0)
    11164
                m6 := mload(0xc0)
    11165
                // Selector of `log(string,address,uint256,bool)`.
    11166
                mstore(0x00, 0xfc4845f0)
    11167
                mstore(0x20, 0x80)
    11168
                mstore(0x40, p1)
    11169
                mstore(0x60, p2)
    11170
                mstore(0x80, p3)
    11171
                writeString(0xa0, p0)
    11172
            }
    11173
            _sendLogPayload(0x1c, 0xc4);
    11174
            /// @solidity memory-safe-assembly
    11175
            assembly {
    11176
                mstore(0x00, m0)
    11177
                mstore(0x20, m1)
    11178
                mstore(0x40, m2)
    11179
                mstore(0x60, m3)
    11180
                mstore(0x80, m4)
    11181
                mstore(0xa0, m5)
    11182
                mstore(0xc0, m6)
    11183
            }
    11184
        }
    11185
    
                                                    
                                                
    11186
        function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {
    11187
            bytes32 m0;
    11188
            bytes32 m1;
    11189
            bytes32 m2;
    11190
            bytes32 m3;
    11191
            bytes32 m4;
    11192
            bytes32 m5;
    11193
            bytes32 m6;
    11194
            /// @solidity memory-safe-assembly
    11195
            assembly {
    11196
                function writeString(pos, w) {
    11197
                    let length := 0
    11198
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11199
                    mstore(pos, length)
    11200
                    let shift := sub(256, shl(3, length))
    11201
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11202
                }
    11203
                m0 := mload(0x00)
    11204
                m1 := mload(0x20)
    11205
                m2 := mload(0x40)
    11206
                m3 := mload(0x60)
    11207
                m4 := mload(0x80)
    11208
                m5 := mload(0xa0)
    11209
                m6 := mload(0xc0)
    11210
                // Selector of `log(string,address,uint256,uint256)`.
    11211
                mstore(0x00, 0xf8f51b1e)
    11212
                mstore(0x20, 0x80)
    11213
                mstore(0x40, p1)
    11214
                mstore(0x60, p2)
    11215
                mstore(0x80, p3)
    11216
                writeString(0xa0, p0)
    11217
            }
    11218
            _sendLogPayload(0x1c, 0xc4);
    11219
            /// @solidity memory-safe-assembly
    11220
            assembly {
    11221
                mstore(0x00, m0)
    11222
                mstore(0x20, m1)
    11223
                mstore(0x40, m2)
    11224
                mstore(0x60, m3)
    11225
                mstore(0x80, m4)
    11226
                mstore(0xa0, m5)
    11227
                mstore(0xc0, m6)
    11228
            }
    11229
        }
    11230
    
                                                    
                                                
    11231
        function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    11232
            bytes32 m0;
    11233
            bytes32 m1;
    11234
            bytes32 m2;
    11235
            bytes32 m3;
    11236
            bytes32 m4;
    11237
            bytes32 m5;
    11238
            bytes32 m6;
    11239
            bytes32 m7;
    11240
            bytes32 m8;
    11241
            /// @solidity memory-safe-assembly
    11242
            assembly {
    11243
                function writeString(pos, w) {
    11244
                    let length := 0
    11245
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11246
                    mstore(pos, length)
    11247
                    let shift := sub(256, shl(3, length))
    11248
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11249
                }
    11250
                m0 := mload(0x00)
    11251
                m1 := mload(0x20)
    11252
                m2 := mload(0x40)
    11253
                m3 := mload(0x60)
    11254
                m4 := mload(0x80)
    11255
                m5 := mload(0xa0)
    11256
                m6 := mload(0xc0)
    11257
                m7 := mload(0xe0)
    11258
                m8 := mload(0x100)
    11259
                // Selector of `log(string,address,uint256,string)`.
    11260
                mstore(0x00, 0x5a477632)
    11261
                mstore(0x20, 0x80)
    11262
                mstore(0x40, p1)
    11263
                mstore(0x60, p2)
    11264
                mstore(0x80, 0xc0)
    11265
                writeString(0xa0, p0)
    11266
                writeString(0xe0, p3)
    11267
            }
    11268
            _sendLogPayload(0x1c, 0x104);
    11269
            /// @solidity memory-safe-assembly
    11270
            assembly {
    11271
                mstore(0x00, m0)
    11272
                mstore(0x20, m1)
    11273
                mstore(0x40, m2)
    11274
                mstore(0x60, m3)
    11275
                mstore(0x80, m4)
    11276
                mstore(0xa0, m5)
    11277
                mstore(0xc0, m6)
    11278
                mstore(0xe0, m7)
    11279
                mstore(0x100, m8)
    11280
            }
    11281
        }
    11282
    
                                                    
                                                
    11283
        function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {
    11284
            bytes32 m0;
    11285
            bytes32 m1;
    11286
            bytes32 m2;
    11287
            bytes32 m3;
    11288
            bytes32 m4;
    11289
            bytes32 m5;
    11290
            bytes32 m6;
    11291
            bytes32 m7;
    11292
            bytes32 m8;
    11293
            /// @solidity memory-safe-assembly
    11294
            assembly {
    11295
                function writeString(pos, w) {
    11296
                    let length := 0
    11297
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11298
                    mstore(pos, length)
    11299
                    let shift := sub(256, shl(3, length))
    11300
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11301
                }
    11302
                m0 := mload(0x00)
    11303
                m1 := mload(0x20)
    11304
                m2 := mload(0x40)
    11305
                m3 := mload(0x60)
    11306
                m4 := mload(0x80)
    11307
                m5 := mload(0xa0)
    11308
                m6 := mload(0xc0)
    11309
                m7 := mload(0xe0)
    11310
                m8 := mload(0x100)
    11311
                // Selector of `log(string,address,string,address)`.
    11312
                mstore(0x00, 0xaabc9a31)
    11313
                mstore(0x20, 0x80)
    11314
                mstore(0x40, p1)
    11315
                mstore(0x60, 0xc0)
    11316
                mstore(0x80, p3)
    11317
                writeString(0xa0, p0)
    11318
                writeString(0xe0, p2)
    11319
            }
    11320
            _sendLogPayload(0x1c, 0x104);
    11321
            /// @solidity memory-safe-assembly
    11322
            assembly {
    11323
                mstore(0x00, m0)
    11324
                mstore(0x20, m1)
    11325
                mstore(0x40, m2)
    11326
                mstore(0x60, m3)
    11327
                mstore(0x80, m4)
    11328
                mstore(0xa0, m5)
    11329
                mstore(0xc0, m6)
    11330
                mstore(0xe0, m7)
    11331
                mstore(0x100, m8)
    11332
            }
    11333
        }
    11334
    
                                                    
                                                
    11335
        function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {
    11336
            bytes32 m0;
    11337
            bytes32 m1;
    11338
            bytes32 m2;
    11339
            bytes32 m3;
    11340
            bytes32 m4;
    11341
            bytes32 m5;
    11342
            bytes32 m6;
    11343
            bytes32 m7;
    11344
            bytes32 m8;
    11345
            /// @solidity memory-safe-assembly
    11346
            assembly {
    11347
                function writeString(pos, w) {
    11348
                    let length := 0
    11349
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11350
                    mstore(pos, length)
    11351
                    let shift := sub(256, shl(3, length))
    11352
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11353
                }
    11354
                m0 := mload(0x00)
    11355
                m1 := mload(0x20)
    11356
                m2 := mload(0x40)
    11357
                m3 := mload(0x60)
    11358
                m4 := mload(0x80)
    11359
                m5 := mload(0xa0)
    11360
                m6 := mload(0xc0)
    11361
                m7 := mload(0xe0)
    11362
                m8 := mload(0x100)
    11363
                // Selector of `log(string,address,string,bool)`.
    11364
                mstore(0x00, 0x5f15d28c)
    11365
                mstore(0x20, 0x80)
    11366
                mstore(0x40, p1)
    11367
                mstore(0x60, 0xc0)
    11368
                mstore(0x80, p3)
    11369
                writeString(0xa0, p0)
    11370
                writeString(0xe0, p2)
    11371
            }
    11372
            _sendLogPayload(0x1c, 0x104);
    11373
            /// @solidity memory-safe-assembly
    11374
            assembly {
    11375
                mstore(0x00, m0)
    11376
                mstore(0x20, m1)
    11377
                mstore(0x40, m2)
    11378
                mstore(0x60, m3)
    11379
                mstore(0x80, m4)
    11380
                mstore(0xa0, m5)
    11381
                mstore(0xc0, m6)
    11382
                mstore(0xe0, m7)
    11383
                mstore(0x100, m8)
    11384
            }
    11385
        }
    11386
    
                                                    
                                                
    11387
        function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    11388
            bytes32 m0;
    11389
            bytes32 m1;
    11390
            bytes32 m2;
    11391
            bytes32 m3;
    11392
            bytes32 m4;
    11393
            bytes32 m5;
    11394
            bytes32 m6;
    11395
            bytes32 m7;
    11396
            bytes32 m8;
    11397
            /// @solidity memory-safe-assembly
    11398
            assembly {
    11399
                function writeString(pos, w) {
    11400
                    let length := 0
    11401
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11402
                    mstore(pos, length)
    11403
                    let shift := sub(256, shl(3, length))
    11404
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11405
                }
    11406
                m0 := mload(0x00)
    11407
                m1 := mload(0x20)
    11408
                m2 := mload(0x40)
    11409
                m3 := mload(0x60)
    11410
                m4 := mload(0x80)
    11411
                m5 := mload(0xa0)
    11412
                m6 := mload(0xc0)
    11413
                m7 := mload(0xe0)
    11414
                m8 := mload(0x100)
    11415
                // Selector of `log(string,address,string,uint256)`.
    11416
                mstore(0x00, 0x91d1112e)
    11417
                mstore(0x20, 0x80)
    11418
                mstore(0x40, p1)
    11419
                mstore(0x60, 0xc0)
    11420
                mstore(0x80, p3)
    11421
                writeString(0xa0, p0)
    11422
                writeString(0xe0, p2)
    11423
            }
    11424
            _sendLogPayload(0x1c, 0x104);
    11425
            /// @solidity memory-safe-assembly
    11426
            assembly {
    11427
                mstore(0x00, m0)
    11428
                mstore(0x20, m1)
    11429
                mstore(0x40, m2)
    11430
                mstore(0x60, m3)
    11431
                mstore(0x80, m4)
    11432
                mstore(0xa0, m5)
    11433
                mstore(0xc0, m6)
    11434
                mstore(0xe0, m7)
    11435
                mstore(0x100, m8)
    11436
            }
    11437
        }
    11438
    
                                                    
                                                
    11439
        function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    11440
            bytes32 m0;
    11441
            bytes32 m1;
    11442
            bytes32 m2;
    11443
            bytes32 m3;
    11444
            bytes32 m4;
    11445
            bytes32 m5;
    11446
            bytes32 m6;
    11447
            bytes32 m7;
    11448
            bytes32 m8;
    11449
            bytes32 m9;
    11450
            bytes32 m10;
    11451
            /// @solidity memory-safe-assembly
    11452
            assembly {
    11453
                function writeString(pos, w) {
    11454
                    let length := 0
    11455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11456
                    mstore(pos, length)
    11457
                    let shift := sub(256, shl(3, length))
    11458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11459
                }
    11460
                m0 := mload(0x00)
    11461
                m1 := mload(0x20)
    11462
                m2 := mload(0x40)
    11463
                m3 := mload(0x60)
    11464
                m4 := mload(0x80)
    11465
                m5 := mload(0xa0)
    11466
                m6 := mload(0xc0)
    11467
                m7 := mload(0xe0)
    11468
                m8 := mload(0x100)
    11469
                m9 := mload(0x120)
    11470
                m10 := mload(0x140)
    11471
                // Selector of `log(string,address,string,string)`.
    11472
                mstore(0x00, 0x245986f2)
    11473
                mstore(0x20, 0x80)
    11474
                mstore(0x40, p1)
    11475
                mstore(0x60, 0xc0)
    11476
                mstore(0x80, 0x100)
    11477
                writeString(0xa0, p0)
    11478
                writeString(0xe0, p2)
    11479
                writeString(0x120, p3)
    11480
            }
    11481
            _sendLogPayload(0x1c, 0x144);
    11482
            /// @solidity memory-safe-assembly
    11483
            assembly {
    11484
                mstore(0x00, m0)
    11485
                mstore(0x20, m1)
    11486
                mstore(0x40, m2)
    11487
                mstore(0x60, m3)
    11488
                mstore(0x80, m4)
    11489
                mstore(0xa0, m5)
    11490
                mstore(0xc0, m6)
    11491
                mstore(0xe0, m7)
    11492
                mstore(0x100, m8)
    11493
                mstore(0x120, m9)
    11494
                mstore(0x140, m10)
    11495
            }
    11496
        }
    11497
    
                                                    
                                                
    11498
        function log(bytes32 p0, bool p1, address p2, address p3) internal pure {
    11499
            bytes32 m0;
    11500
            bytes32 m1;
    11501
            bytes32 m2;
    11502
            bytes32 m3;
    11503
            bytes32 m4;
    11504
            bytes32 m5;
    11505
            bytes32 m6;
    11506
            /// @solidity memory-safe-assembly
    11507
            assembly {
    11508
                function writeString(pos, w) {
    11509
                    let length := 0
    11510
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11511
                    mstore(pos, length)
    11512
                    let shift := sub(256, shl(3, length))
    11513
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11514
                }
    11515
                m0 := mload(0x00)
    11516
                m1 := mload(0x20)
    11517
                m2 := mload(0x40)
    11518
                m3 := mload(0x60)
    11519
                m4 := mload(0x80)
    11520
                m5 := mload(0xa0)
    11521
                m6 := mload(0xc0)
    11522
                // Selector of `log(string,bool,address,address)`.
    11523
                mstore(0x00, 0x33e9dd1d)
    11524
                mstore(0x20, 0x80)
    11525
                mstore(0x40, p1)
    11526
                mstore(0x60, p2)
    11527
                mstore(0x80, p3)
    11528
                writeString(0xa0, p0)
    11529
            }
    11530
            _sendLogPayload(0x1c, 0xc4);
    11531
            /// @solidity memory-safe-assembly
    11532
            assembly {
    11533
                mstore(0x00, m0)
    11534
                mstore(0x20, m1)
    11535
                mstore(0x40, m2)
    11536
                mstore(0x60, m3)
    11537
                mstore(0x80, m4)
    11538
                mstore(0xa0, m5)
    11539
                mstore(0xc0, m6)
    11540
            }
    11541
        }
    11542
    
                                                    
                                                
    11543
        function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {
    11544
            bytes32 m0;
    11545
            bytes32 m1;
    11546
            bytes32 m2;
    11547
            bytes32 m3;
    11548
            bytes32 m4;
    11549
            bytes32 m5;
    11550
            bytes32 m6;
    11551
            /// @solidity memory-safe-assembly
    11552
            assembly {
    11553
                function writeString(pos, w) {
    11554
                    let length := 0
    11555
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11556
                    mstore(pos, length)
    11557
                    let shift := sub(256, shl(3, length))
    11558
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11559
                }
    11560
                m0 := mload(0x00)
    11561
                m1 := mload(0x20)
    11562
                m2 := mload(0x40)
    11563
                m3 := mload(0x60)
    11564
                m4 := mload(0x80)
    11565
                m5 := mload(0xa0)
    11566
                m6 := mload(0xc0)
    11567
                // Selector of `log(string,bool,address,bool)`.
    11568
                mstore(0x00, 0x958c28c6)
    11569
                mstore(0x20, 0x80)
    11570
                mstore(0x40, p1)
    11571
                mstore(0x60, p2)
    11572
                mstore(0x80, p3)
    11573
                writeString(0xa0, p0)
    11574
            }
    11575
            _sendLogPayload(0x1c, 0xc4);
    11576
            /// @solidity memory-safe-assembly
    11577
            assembly {
    11578
                mstore(0x00, m0)
    11579
                mstore(0x20, m1)
    11580
                mstore(0x40, m2)
    11581
                mstore(0x60, m3)
    11582
                mstore(0x80, m4)
    11583
                mstore(0xa0, m5)
    11584
                mstore(0xc0, m6)
    11585
            }
    11586
        }
    11587
    
                                                    
                                                
    11588
        function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {
    11589
            bytes32 m0;
    11590
            bytes32 m1;
    11591
            bytes32 m2;
    11592
            bytes32 m3;
    11593
            bytes32 m4;
    11594
            bytes32 m5;
    11595
            bytes32 m6;
    11596
            /// @solidity memory-safe-assembly
    11597
            assembly {
    11598
                function writeString(pos, w) {
    11599
                    let length := 0
    11600
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11601
                    mstore(pos, length)
    11602
                    let shift := sub(256, shl(3, length))
    11603
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11604
                }
    11605
                m0 := mload(0x00)
    11606
                m1 := mload(0x20)
    11607
                m2 := mload(0x40)
    11608
                m3 := mload(0x60)
    11609
                m4 := mload(0x80)
    11610
                m5 := mload(0xa0)
    11611
                m6 := mload(0xc0)
    11612
                // Selector of `log(string,bool,address,uint256)`.
    11613
                mstore(0x00, 0x5d08bb05)
    11614
                mstore(0x20, 0x80)
    11615
                mstore(0x40, p1)
    11616
                mstore(0x60, p2)
    11617
                mstore(0x80, p3)
    11618
                writeString(0xa0, p0)
    11619
            }
    11620
            _sendLogPayload(0x1c, 0xc4);
    11621
            /// @solidity memory-safe-assembly
    11622
            assembly {
    11623
                mstore(0x00, m0)
    11624
                mstore(0x20, m1)
    11625
                mstore(0x40, m2)
    11626
                mstore(0x60, m3)
    11627
                mstore(0x80, m4)
    11628
                mstore(0xa0, m5)
    11629
                mstore(0xc0, m6)
    11630
            }
    11631
        }
    11632
    
                                                    
                                                
    11633
        function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {
    11634
            bytes32 m0;
    11635
            bytes32 m1;
    11636
            bytes32 m2;
    11637
            bytes32 m3;
    11638
            bytes32 m4;
    11639
            bytes32 m5;
    11640
            bytes32 m6;
    11641
            bytes32 m7;
    11642
            bytes32 m8;
    11643
            /// @solidity memory-safe-assembly
    11644
            assembly {
    11645
                function writeString(pos, w) {
    11646
                    let length := 0
    11647
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11648
                    mstore(pos, length)
    11649
                    let shift := sub(256, shl(3, length))
    11650
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11651
                }
    11652
                m0 := mload(0x00)
    11653
                m1 := mload(0x20)
    11654
                m2 := mload(0x40)
    11655
                m3 := mload(0x60)
    11656
                m4 := mload(0x80)
    11657
                m5 := mload(0xa0)
    11658
                m6 := mload(0xc0)
    11659
                m7 := mload(0xe0)
    11660
                m8 := mload(0x100)
    11661
                // Selector of `log(string,bool,address,string)`.
    11662
                mstore(0x00, 0x2d8e33a4)
    11663
                mstore(0x20, 0x80)
    11664
                mstore(0x40, p1)
    11665
                mstore(0x60, p2)
    11666
                mstore(0x80, 0xc0)
    11667
                writeString(0xa0, p0)
    11668
                writeString(0xe0, p3)
    11669
            }
    11670
            _sendLogPayload(0x1c, 0x104);
    11671
            /// @solidity memory-safe-assembly
    11672
            assembly {
    11673
                mstore(0x00, m0)
    11674
                mstore(0x20, m1)
    11675
                mstore(0x40, m2)
    11676
                mstore(0x60, m3)
    11677
                mstore(0x80, m4)
    11678
                mstore(0xa0, m5)
    11679
                mstore(0xc0, m6)
    11680
                mstore(0xe0, m7)
    11681
                mstore(0x100, m8)
    11682
            }
    11683
        }
    11684
    
                                                    
                                                
    11685
        function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {
    11686
            bytes32 m0;
    11687
            bytes32 m1;
    11688
            bytes32 m2;
    11689
            bytes32 m3;
    11690
            bytes32 m4;
    11691
            bytes32 m5;
    11692
            bytes32 m6;
    11693
            /// @solidity memory-safe-assembly
    11694
            assembly {
    11695
                function writeString(pos, w) {
    11696
                    let length := 0
    11697
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11698
                    mstore(pos, length)
    11699
                    let shift := sub(256, shl(3, length))
    11700
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11701
                }
    11702
                m0 := mload(0x00)
    11703
                m1 := mload(0x20)
    11704
                m2 := mload(0x40)
    11705
                m3 := mload(0x60)
    11706
                m4 := mload(0x80)
    11707
                m5 := mload(0xa0)
    11708
                m6 := mload(0xc0)
    11709
                // Selector of `log(string,bool,bool,address)`.
    11710
                mstore(0x00, 0x7190a529)
    11711
                mstore(0x20, 0x80)
    11712
                mstore(0x40, p1)
    11713
                mstore(0x60, p2)
    11714
                mstore(0x80, p3)
    11715
                writeString(0xa0, p0)
    11716
            }
    11717
            _sendLogPayload(0x1c, 0xc4);
    11718
            /// @solidity memory-safe-assembly
    11719
            assembly {
    11720
                mstore(0x00, m0)
    11721
                mstore(0x20, m1)
    11722
                mstore(0x40, m2)
    11723
                mstore(0x60, m3)
    11724
                mstore(0x80, m4)
    11725
                mstore(0xa0, m5)
    11726
                mstore(0xc0, m6)
    11727
            }
    11728
        }
    11729
    
                                                    
                                                
    11730
        function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {
    11731
            bytes32 m0;
    11732
            bytes32 m1;
    11733
            bytes32 m2;
    11734
            bytes32 m3;
    11735
            bytes32 m4;
    11736
            bytes32 m5;
    11737
            bytes32 m6;
    11738
            /// @solidity memory-safe-assembly
    11739
            assembly {
    11740
                function writeString(pos, w) {
    11741
                    let length := 0
    11742
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11743
                    mstore(pos, length)
    11744
                    let shift := sub(256, shl(3, length))
    11745
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11746
                }
    11747
                m0 := mload(0x00)
    11748
                m1 := mload(0x20)
    11749
                m2 := mload(0x40)
    11750
                m3 := mload(0x60)
    11751
                m4 := mload(0x80)
    11752
                m5 := mload(0xa0)
    11753
                m6 := mload(0xc0)
    11754
                // Selector of `log(string,bool,bool,bool)`.
    11755
                mstore(0x00, 0x895af8c5)
    11756
                mstore(0x20, 0x80)
    11757
                mstore(0x40, p1)
    11758
                mstore(0x60, p2)
    11759
                mstore(0x80, p3)
    11760
                writeString(0xa0, p0)
    11761
            }
    11762
            _sendLogPayload(0x1c, 0xc4);
    11763
            /// @solidity memory-safe-assembly
    11764
            assembly {
    11765
                mstore(0x00, m0)
    11766
                mstore(0x20, m1)
    11767
                mstore(0x40, m2)
    11768
                mstore(0x60, m3)
    11769
                mstore(0x80, m4)
    11770
                mstore(0xa0, m5)
    11771
                mstore(0xc0, m6)
    11772
            }
    11773
        }
    11774
    
                                                    
                                                
    11775
        function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {
    11776
            bytes32 m0;
    11777
            bytes32 m1;
    11778
            bytes32 m2;
    11779
            bytes32 m3;
    11780
            bytes32 m4;
    11781
            bytes32 m5;
    11782
            bytes32 m6;
    11783
            /// @solidity memory-safe-assembly
    11784
            assembly {
    11785
                function writeString(pos, w) {
    11786
                    let length := 0
    11787
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11788
                    mstore(pos, length)
    11789
                    let shift := sub(256, shl(3, length))
    11790
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11791
                }
    11792
                m0 := mload(0x00)
    11793
                m1 := mload(0x20)
    11794
                m2 := mload(0x40)
    11795
                m3 := mload(0x60)
    11796
                m4 := mload(0x80)
    11797
                m5 := mload(0xa0)
    11798
                m6 := mload(0xc0)
    11799
                // Selector of `log(string,bool,bool,uint256)`.
    11800
                mstore(0x00, 0x8e3f78a9)
    11801
                mstore(0x20, 0x80)
    11802
                mstore(0x40, p1)
    11803
                mstore(0x60, p2)
    11804
                mstore(0x80, p3)
    11805
                writeString(0xa0, p0)
    11806
            }
    11807
            _sendLogPayload(0x1c, 0xc4);
    11808
            /// @solidity memory-safe-assembly
    11809
            assembly {
    11810
                mstore(0x00, m0)
    11811
                mstore(0x20, m1)
    11812
                mstore(0x40, m2)
    11813
                mstore(0x60, m3)
    11814
                mstore(0x80, m4)
    11815
                mstore(0xa0, m5)
    11816
                mstore(0xc0, m6)
    11817
            }
    11818
        }
    11819
    
                                                    
                                                
    11820
        function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {
    11821
            bytes32 m0;
    11822
            bytes32 m1;
    11823
            bytes32 m2;
    11824
            bytes32 m3;
    11825
            bytes32 m4;
    11826
            bytes32 m5;
    11827
            bytes32 m6;
    11828
            bytes32 m7;
    11829
            bytes32 m8;
    11830
            /// @solidity memory-safe-assembly
    11831
            assembly {
    11832
                function writeString(pos, w) {
    11833
                    let length := 0
    11834
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11835
                    mstore(pos, length)
    11836
                    let shift := sub(256, shl(3, length))
    11837
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11838
                }
    11839
                m0 := mload(0x00)
    11840
                m1 := mload(0x20)
    11841
                m2 := mload(0x40)
    11842
                m3 := mload(0x60)
    11843
                m4 := mload(0x80)
    11844
                m5 := mload(0xa0)
    11845
                m6 := mload(0xc0)
    11846
                m7 := mload(0xe0)
    11847
                m8 := mload(0x100)
    11848
                // Selector of `log(string,bool,bool,string)`.
    11849
                mstore(0x00, 0x9d22d5dd)
    11850
                mstore(0x20, 0x80)
    11851
                mstore(0x40, p1)
    11852
                mstore(0x60, p2)
    11853
                mstore(0x80, 0xc0)
    11854
                writeString(0xa0, p0)
    11855
                writeString(0xe0, p3)
    11856
            }
    11857
            _sendLogPayload(0x1c, 0x104);
    11858
            /// @solidity memory-safe-assembly
    11859
            assembly {
    11860
                mstore(0x00, m0)
    11861
                mstore(0x20, m1)
    11862
                mstore(0x40, m2)
    11863
                mstore(0x60, m3)
    11864
                mstore(0x80, m4)
    11865
                mstore(0xa0, m5)
    11866
                mstore(0xc0, m6)
    11867
                mstore(0xe0, m7)
    11868
                mstore(0x100, m8)
    11869
            }
    11870
        }
    11871
    
                                                    
                                                
    11872
        function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {
    11873
            bytes32 m0;
    11874
            bytes32 m1;
    11875
            bytes32 m2;
    11876
            bytes32 m3;
    11877
            bytes32 m4;
    11878
            bytes32 m5;
    11879
            bytes32 m6;
    11880
            /// @solidity memory-safe-assembly
    11881
            assembly {
    11882
                function writeString(pos, w) {
    11883
                    let length := 0
    11884
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11885
                    mstore(pos, length)
    11886
                    let shift := sub(256, shl(3, length))
    11887
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11888
                }
    11889
                m0 := mload(0x00)
    11890
                m1 := mload(0x20)
    11891
                m2 := mload(0x40)
    11892
                m3 := mload(0x60)
    11893
                m4 := mload(0x80)
    11894
                m5 := mload(0xa0)
    11895
                m6 := mload(0xc0)
    11896
                // Selector of `log(string,bool,uint256,address)`.
    11897
                mstore(0x00, 0x935e09bf)
    11898
                mstore(0x20, 0x80)
    11899
                mstore(0x40, p1)
    11900
                mstore(0x60, p2)
    11901
                mstore(0x80, p3)
    11902
                writeString(0xa0, p0)
    11903
            }
    11904
            _sendLogPayload(0x1c, 0xc4);
    11905
            /// @solidity memory-safe-assembly
    11906
            assembly {
    11907
                mstore(0x00, m0)
    11908
                mstore(0x20, m1)
    11909
                mstore(0x40, m2)
    11910
                mstore(0x60, m3)
    11911
                mstore(0x80, m4)
    11912
                mstore(0xa0, m5)
    11913
                mstore(0xc0, m6)
    11914
            }
    11915
        }
    11916
    
                                                    
                                                
    11917
        function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {
    11918
            bytes32 m0;
    11919
            bytes32 m1;
    11920
            bytes32 m2;
    11921
            bytes32 m3;
    11922
            bytes32 m4;
    11923
            bytes32 m5;
    11924
            bytes32 m6;
    11925
            /// @solidity memory-safe-assembly
    11926
            assembly {
    11927
                function writeString(pos, w) {
    11928
                    let length := 0
    11929
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11930
                    mstore(pos, length)
    11931
                    let shift := sub(256, shl(3, length))
    11932
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11933
                }
    11934
                m0 := mload(0x00)
    11935
                m1 := mload(0x20)
    11936
                m2 := mload(0x40)
    11937
                m3 := mload(0x60)
    11938
                m4 := mload(0x80)
    11939
                m5 := mload(0xa0)
    11940
                m6 := mload(0xc0)
    11941
                // Selector of `log(string,bool,uint256,bool)`.
    11942
                mstore(0x00, 0x8af7cf8a)
    11943
                mstore(0x20, 0x80)
    11944
                mstore(0x40, p1)
    11945
                mstore(0x60, p2)
    11946
                mstore(0x80, p3)
    11947
                writeString(0xa0, p0)
    11948
            }
    11949
            _sendLogPayload(0x1c, 0xc4);
    11950
            /// @solidity memory-safe-assembly
    11951
            assembly {
    11952
                mstore(0x00, m0)
    11953
                mstore(0x20, m1)
    11954
                mstore(0x40, m2)
    11955
                mstore(0x60, m3)
    11956
                mstore(0x80, m4)
    11957
                mstore(0xa0, m5)
    11958
                mstore(0xc0, m6)
    11959
            }
    11960
        }
    11961
    
                                                    
                                                
    11962
        function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    11963
            bytes32 m0;
    11964
            bytes32 m1;
    11965
            bytes32 m2;
    11966
            bytes32 m3;
    11967
            bytes32 m4;
    11968
            bytes32 m5;
    11969
            bytes32 m6;
    11970
            /// @solidity memory-safe-assembly
    11971
            assembly {
    11972
                function writeString(pos, w) {
    11973
                    let length := 0
    11974
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11975
                    mstore(pos, length)
    11976
                    let shift := sub(256, shl(3, length))
    11977
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11978
                }
    11979
                m0 := mload(0x00)
    11980
                m1 := mload(0x20)
    11981
                m2 := mload(0x40)
    11982
                m3 := mload(0x60)
    11983
                m4 := mload(0x80)
    11984
                m5 := mload(0xa0)
    11985
                m6 := mload(0xc0)
    11986
                // Selector of `log(string,bool,uint256,uint256)`.
    11987
                mstore(0x00, 0x64b5bb67)
    11988
                mstore(0x20, 0x80)
    11989
                mstore(0x40, p1)
    11990
                mstore(0x60, p2)
    11991
                mstore(0x80, p3)
    11992
                writeString(0xa0, p0)
    11993
            }
    11994
            _sendLogPayload(0x1c, 0xc4);
    11995
            /// @solidity memory-safe-assembly
    11996
            assembly {
    11997
                mstore(0x00, m0)
    11998
                mstore(0x20, m1)
    11999
                mstore(0x40, m2)
    12000
                mstore(0x60, m3)
    12001
                mstore(0x80, m4)
    12002
                mstore(0xa0, m5)
    12003
                mstore(0xc0, m6)
    12004
            }
    12005
        }
    12006
    
                                                    
                                                
    12007
        function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    12008
            bytes32 m0;
    12009
            bytes32 m1;
    12010
            bytes32 m2;
    12011
            bytes32 m3;
    12012
            bytes32 m4;
    12013
            bytes32 m5;
    12014
            bytes32 m6;
    12015
            bytes32 m7;
    12016
            bytes32 m8;
    12017
            /// @solidity memory-safe-assembly
    12018
            assembly {
    12019
                function writeString(pos, w) {
    12020
                    let length := 0
    12021
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12022
                    mstore(pos, length)
    12023
                    let shift := sub(256, shl(3, length))
    12024
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12025
                }
    12026
                m0 := mload(0x00)
    12027
                m1 := mload(0x20)
    12028
                m2 := mload(0x40)
    12029
                m3 := mload(0x60)
    12030
                m4 := mload(0x80)
    12031
                m5 := mload(0xa0)
    12032
                m6 := mload(0xc0)
    12033
                m7 := mload(0xe0)
    12034
                m8 := mload(0x100)
    12035
                // Selector of `log(string,bool,uint256,string)`.
    12036
                mstore(0x00, 0x742d6ee7)
    12037
                mstore(0x20, 0x80)
    12038
                mstore(0x40, p1)
    12039
                mstore(0x60, p2)
    12040
                mstore(0x80, 0xc0)
    12041
                writeString(0xa0, p0)
    12042
                writeString(0xe0, p3)
    12043
            }
    12044
            _sendLogPayload(0x1c, 0x104);
    12045
            /// @solidity memory-safe-assembly
    12046
            assembly {
    12047
                mstore(0x00, m0)
    12048
                mstore(0x20, m1)
    12049
                mstore(0x40, m2)
    12050
                mstore(0x60, m3)
    12051
                mstore(0x80, m4)
    12052
                mstore(0xa0, m5)
    12053
                mstore(0xc0, m6)
    12054
                mstore(0xe0, m7)
    12055
                mstore(0x100, m8)
    12056
            }
    12057
        }
    12058
    
                                                    
                                                
    12059
        function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {
    12060
            bytes32 m0;
    12061
            bytes32 m1;
    12062
            bytes32 m2;
    12063
            bytes32 m3;
    12064
            bytes32 m4;
    12065
            bytes32 m5;
    12066
            bytes32 m6;
    12067
            bytes32 m7;
    12068
            bytes32 m8;
    12069
            /// @solidity memory-safe-assembly
    12070
            assembly {
    12071
                function writeString(pos, w) {
    12072
                    let length := 0
    12073
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12074
                    mstore(pos, length)
    12075
                    let shift := sub(256, shl(3, length))
    12076
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12077
                }
    12078
                m0 := mload(0x00)
    12079
                m1 := mload(0x20)
    12080
                m2 := mload(0x40)
    12081
                m3 := mload(0x60)
    12082
                m4 := mload(0x80)
    12083
                m5 := mload(0xa0)
    12084
                m6 := mload(0xc0)
    12085
                m7 := mload(0xe0)
    12086
                m8 := mload(0x100)
    12087
                // Selector of `log(string,bool,string,address)`.
    12088
                mstore(0x00, 0xe0625b29)
    12089
                mstore(0x20, 0x80)
    12090
                mstore(0x40, p1)
    12091
                mstore(0x60, 0xc0)
    12092
                mstore(0x80, p3)
    12093
                writeString(0xa0, p0)
    12094
                writeString(0xe0, p2)
    12095
            }
    12096
            _sendLogPayload(0x1c, 0x104);
    12097
            /// @solidity memory-safe-assembly
    12098
            assembly {
    12099
                mstore(0x00, m0)
    12100
                mstore(0x20, m1)
    12101
                mstore(0x40, m2)
    12102
                mstore(0x60, m3)
    12103
                mstore(0x80, m4)
    12104
                mstore(0xa0, m5)
    12105
                mstore(0xc0, m6)
    12106
                mstore(0xe0, m7)
    12107
                mstore(0x100, m8)
    12108
            }
    12109
        }
    12110
    
                                                    
                                                
    12111
        function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {
    12112
            bytes32 m0;
    12113
            bytes32 m1;
    12114
            bytes32 m2;
    12115
            bytes32 m3;
    12116
            bytes32 m4;
    12117
            bytes32 m5;
    12118
            bytes32 m6;
    12119
            bytes32 m7;
    12120
            bytes32 m8;
    12121
            /// @solidity memory-safe-assembly
    12122
            assembly {
    12123
                function writeString(pos, w) {
    12124
                    let length := 0
    12125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12126
                    mstore(pos, length)
    12127
                    let shift := sub(256, shl(3, length))
    12128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12129
                }
    12130
                m0 := mload(0x00)
    12131
                m1 := mload(0x20)
    12132
                m2 := mload(0x40)
    12133
                m3 := mload(0x60)
    12134
                m4 := mload(0x80)
    12135
                m5 := mload(0xa0)
    12136
                m6 := mload(0xc0)
    12137
                m7 := mload(0xe0)
    12138
                m8 := mload(0x100)
    12139
                // Selector of `log(string,bool,string,bool)`.
    12140
                mstore(0x00, 0x3f8a701d)
    12141
                mstore(0x20, 0x80)
    12142
                mstore(0x40, p1)
    12143
                mstore(0x60, 0xc0)
    12144
                mstore(0x80, p3)
    12145
                writeString(0xa0, p0)
    12146
                writeString(0xe0, p2)
    12147
            }
    12148
            _sendLogPayload(0x1c, 0x104);
    12149
            /// @solidity memory-safe-assembly
    12150
            assembly {
    12151
                mstore(0x00, m0)
    12152
                mstore(0x20, m1)
    12153
                mstore(0x40, m2)
    12154
                mstore(0x60, m3)
    12155
                mstore(0x80, m4)
    12156
                mstore(0xa0, m5)
    12157
                mstore(0xc0, m6)
    12158
                mstore(0xe0, m7)
    12159
                mstore(0x100, m8)
    12160
            }
    12161
        }
    12162
    
                                                    
                                                
    12163
        function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    12164
            bytes32 m0;
    12165
            bytes32 m1;
    12166
            bytes32 m2;
    12167
            bytes32 m3;
    12168
            bytes32 m4;
    12169
            bytes32 m5;
    12170
            bytes32 m6;
    12171
            bytes32 m7;
    12172
            bytes32 m8;
    12173
            /// @solidity memory-safe-assembly
    12174
            assembly {
    12175
                function writeString(pos, w) {
    12176
                    let length := 0
    12177
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12178
                    mstore(pos, length)
    12179
                    let shift := sub(256, shl(3, length))
    12180
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12181
                }
    12182
                m0 := mload(0x00)
    12183
                m1 := mload(0x20)
    12184
                m2 := mload(0x40)
    12185
                m3 := mload(0x60)
    12186
                m4 := mload(0x80)
    12187
                m5 := mload(0xa0)
    12188
                m6 := mload(0xc0)
    12189
                m7 := mload(0xe0)
    12190
                m8 := mload(0x100)
    12191
                // Selector of `log(string,bool,string,uint256)`.
    12192
                mstore(0x00, 0x24f91465)
    12193
                mstore(0x20, 0x80)
    12194
                mstore(0x40, p1)
    12195
                mstore(0x60, 0xc0)
    12196
                mstore(0x80, p3)
    12197
                writeString(0xa0, p0)
    12198
                writeString(0xe0, p2)
    12199
            }
    12200
            _sendLogPayload(0x1c, 0x104);
    12201
            /// @solidity memory-safe-assembly
    12202
            assembly {
    12203
                mstore(0x00, m0)
    12204
                mstore(0x20, m1)
    12205
                mstore(0x40, m2)
    12206
                mstore(0x60, m3)
    12207
                mstore(0x80, m4)
    12208
                mstore(0xa0, m5)
    12209
                mstore(0xc0, m6)
    12210
                mstore(0xe0, m7)
    12211
                mstore(0x100, m8)
    12212
            }
    12213
        }
    12214
    
                                                    
                                                
    12215
        function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    12216
            bytes32 m0;
    12217
            bytes32 m1;
    12218
            bytes32 m2;
    12219
            bytes32 m3;
    12220
            bytes32 m4;
    12221
            bytes32 m5;
    12222
            bytes32 m6;
    12223
            bytes32 m7;
    12224
            bytes32 m8;
    12225
            bytes32 m9;
    12226
            bytes32 m10;
    12227
            /// @solidity memory-safe-assembly
    12228
            assembly {
    12229
                function writeString(pos, w) {
    12230
                    let length := 0
    12231
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12232
                    mstore(pos, length)
    12233
                    let shift := sub(256, shl(3, length))
    12234
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12235
                }
    12236
                m0 := mload(0x00)
    12237
                m1 := mload(0x20)
    12238
                m2 := mload(0x40)
    12239
                m3 := mload(0x60)
    12240
                m4 := mload(0x80)
    12241
                m5 := mload(0xa0)
    12242
                m6 := mload(0xc0)
    12243
                m7 := mload(0xe0)
    12244
                m8 := mload(0x100)
    12245
                m9 := mload(0x120)
    12246
                m10 := mload(0x140)
    12247
                // Selector of `log(string,bool,string,string)`.
    12248
                mstore(0x00, 0xa826caeb)
    12249
                mstore(0x20, 0x80)
    12250
                mstore(0x40, p1)
    12251
                mstore(0x60, 0xc0)
    12252
                mstore(0x80, 0x100)
    12253
                writeString(0xa0, p0)
    12254
                writeString(0xe0, p2)
    12255
                writeString(0x120, p3)
    12256
            }
    12257
            _sendLogPayload(0x1c, 0x144);
    12258
            /// @solidity memory-safe-assembly
    12259
            assembly {
    12260
                mstore(0x00, m0)
    12261
                mstore(0x20, m1)
    12262
                mstore(0x40, m2)
    12263
                mstore(0x60, m3)
    12264
                mstore(0x80, m4)
    12265
                mstore(0xa0, m5)
    12266
                mstore(0xc0, m6)
    12267
                mstore(0xe0, m7)
    12268
                mstore(0x100, m8)
    12269
                mstore(0x120, m9)
    12270
                mstore(0x140, m10)
    12271
            }
    12272
        }
    12273
    
                                                    
                                                
    12274
        function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {
    12275
            bytes32 m0;
    12276
            bytes32 m1;
    12277
            bytes32 m2;
    12278
            bytes32 m3;
    12279
            bytes32 m4;
    12280
            bytes32 m5;
    12281
            bytes32 m6;
    12282
            /// @solidity memory-safe-assembly
    12283
            assembly {
    12284
                function writeString(pos, w) {
    12285
                    let length := 0
    12286
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12287
                    mstore(pos, length)
    12288
                    let shift := sub(256, shl(3, length))
    12289
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12290
                }
    12291
                m0 := mload(0x00)
    12292
                m1 := mload(0x20)
    12293
                m2 := mload(0x40)
    12294
                m3 := mload(0x60)
    12295
                m4 := mload(0x80)
    12296
                m5 := mload(0xa0)
    12297
                m6 := mload(0xc0)
    12298
                // Selector of `log(string,uint256,address,address)`.
    12299
                mstore(0x00, 0x5ea2b7ae)
    12300
                mstore(0x20, 0x80)
    12301
                mstore(0x40, p1)
    12302
                mstore(0x60, p2)
    12303
                mstore(0x80, p3)
    12304
                writeString(0xa0, p0)
    12305
            }
    12306
            _sendLogPayload(0x1c, 0xc4);
    12307
            /// @solidity memory-safe-assembly
    12308
            assembly {
    12309
                mstore(0x00, m0)
    12310
                mstore(0x20, m1)
    12311
                mstore(0x40, m2)
    12312
                mstore(0x60, m3)
    12313
                mstore(0x80, m4)
    12314
                mstore(0xa0, m5)
    12315
                mstore(0xc0, m6)
    12316
            }
    12317
        }
    12318
    
                                                    
                                                
    12319
        function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {
    12320
            bytes32 m0;
    12321
            bytes32 m1;
    12322
            bytes32 m2;
    12323
            bytes32 m3;
    12324
            bytes32 m4;
    12325
            bytes32 m5;
    12326
            bytes32 m6;
    12327
            /// @solidity memory-safe-assembly
    12328
            assembly {
    12329
                function writeString(pos, w) {
    12330
                    let length := 0
    12331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12332
                    mstore(pos, length)
    12333
                    let shift := sub(256, shl(3, length))
    12334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12335
                }
    12336
                m0 := mload(0x00)
    12337
                m1 := mload(0x20)
    12338
                m2 := mload(0x40)
    12339
                m3 := mload(0x60)
    12340
                m4 := mload(0x80)
    12341
                m5 := mload(0xa0)
    12342
                m6 := mload(0xc0)
    12343
                // Selector of `log(string,uint256,address,bool)`.
    12344
                mstore(0x00, 0x82112a42)
    12345
                mstore(0x20, 0x80)
    12346
                mstore(0x40, p1)
    12347
                mstore(0x60, p2)
    12348
                mstore(0x80, p3)
    12349
                writeString(0xa0, p0)
    12350
            }
    12351
            _sendLogPayload(0x1c, 0xc4);
    12352
            /// @solidity memory-safe-assembly
    12353
            assembly {
    12354
                mstore(0x00, m0)
    12355
                mstore(0x20, m1)
    12356
                mstore(0x40, m2)
    12357
                mstore(0x60, m3)
    12358
                mstore(0x80, m4)
    12359
                mstore(0xa0, m5)
    12360
                mstore(0xc0, m6)
    12361
            }
    12362
        }
    12363
    
                                                    
                                                
    12364
        function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {
    12365
            bytes32 m0;
    12366
            bytes32 m1;
    12367
            bytes32 m2;
    12368
            bytes32 m3;
    12369
            bytes32 m4;
    12370
            bytes32 m5;
    12371
            bytes32 m6;
    12372
            /// @solidity memory-safe-assembly
    12373
            assembly {
    12374
                function writeString(pos, w) {
    12375
                    let length := 0
    12376
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12377
                    mstore(pos, length)
    12378
                    let shift := sub(256, shl(3, length))
    12379
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12380
                }
    12381
                m0 := mload(0x00)
    12382
                m1 := mload(0x20)
    12383
                m2 := mload(0x40)
    12384
                m3 := mload(0x60)
    12385
                m4 := mload(0x80)
    12386
                m5 := mload(0xa0)
    12387
                m6 := mload(0xc0)
    12388
                // Selector of `log(string,uint256,address,uint256)`.
    12389
                mstore(0x00, 0x4f04fdc6)
    12390
                mstore(0x20, 0x80)
    12391
                mstore(0x40, p1)
    12392
                mstore(0x60, p2)
    12393
                mstore(0x80, p3)
    12394
                writeString(0xa0, p0)
    12395
            }
    12396
            _sendLogPayload(0x1c, 0xc4);
    12397
            /// @solidity memory-safe-assembly
    12398
            assembly {
    12399
                mstore(0x00, m0)
    12400
                mstore(0x20, m1)
    12401
                mstore(0x40, m2)
    12402
                mstore(0x60, m3)
    12403
                mstore(0x80, m4)
    12404
                mstore(0xa0, m5)
    12405
                mstore(0xc0, m6)
    12406
            }
    12407
        }
    12408
    
                                                    
                                                
    12409
        function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    12410
            bytes32 m0;
    12411
            bytes32 m1;
    12412
            bytes32 m2;
    12413
            bytes32 m3;
    12414
            bytes32 m4;
    12415
            bytes32 m5;
    12416
            bytes32 m6;
    12417
            bytes32 m7;
    12418
            bytes32 m8;
    12419
            /// @solidity memory-safe-assembly
    12420
            assembly {
    12421
                function writeString(pos, w) {
    12422
                    let length := 0
    12423
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12424
                    mstore(pos, length)
    12425
                    let shift := sub(256, shl(3, length))
    12426
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12427
                }
    12428
                m0 := mload(0x00)
    12429
                m1 := mload(0x20)
    12430
                m2 := mload(0x40)
    12431
                m3 := mload(0x60)
    12432
                m4 := mload(0x80)
    12433
                m5 := mload(0xa0)
    12434
                m6 := mload(0xc0)
    12435
                m7 := mload(0xe0)
    12436
                m8 := mload(0x100)
    12437
                // Selector of `log(string,uint256,address,string)`.
    12438
                mstore(0x00, 0x9ffb2f93)
    12439
                mstore(0x20, 0x80)
    12440
                mstore(0x40, p1)
    12441
                mstore(0x60, p2)
    12442
                mstore(0x80, 0xc0)
    12443
                writeString(0xa0, p0)
    12444
                writeString(0xe0, p3)
    12445
            }
    12446
            _sendLogPayload(0x1c, 0x104);
    12447
            /// @solidity memory-safe-assembly
    12448
            assembly {
    12449
                mstore(0x00, m0)
    12450
                mstore(0x20, m1)
    12451
                mstore(0x40, m2)
    12452
                mstore(0x60, m3)
    12453
                mstore(0x80, m4)
    12454
                mstore(0xa0, m5)
    12455
                mstore(0xc0, m6)
    12456
                mstore(0xe0, m7)
    12457
                mstore(0x100, m8)
    12458
            }
    12459
        }
    12460
    
                                                    
                                                
    12461
        function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {
    12462
            bytes32 m0;
    12463
            bytes32 m1;
    12464
            bytes32 m2;
    12465
            bytes32 m3;
    12466
            bytes32 m4;
    12467
            bytes32 m5;
    12468
            bytes32 m6;
    12469
            /// @solidity memory-safe-assembly
    12470
            assembly {
    12471
                function writeString(pos, w) {
    12472
                    let length := 0
    12473
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12474
                    mstore(pos, length)
    12475
                    let shift := sub(256, shl(3, length))
    12476
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12477
                }
    12478
                m0 := mload(0x00)
    12479
                m1 := mload(0x20)
    12480
                m2 := mload(0x40)
    12481
                m3 := mload(0x60)
    12482
                m4 := mload(0x80)
    12483
                m5 := mload(0xa0)
    12484
                m6 := mload(0xc0)
    12485
                // Selector of `log(string,uint256,bool,address)`.
    12486
                mstore(0x00, 0xe0e95b98)
    12487
                mstore(0x20, 0x80)
    12488
                mstore(0x40, p1)
    12489
                mstore(0x60, p2)
    12490
                mstore(0x80, p3)
    12491
                writeString(0xa0, p0)
    12492
            }
    12493
            _sendLogPayload(0x1c, 0xc4);
    12494
            /// @solidity memory-safe-assembly
    12495
            assembly {
    12496
                mstore(0x00, m0)
    12497
                mstore(0x20, m1)
    12498
                mstore(0x40, m2)
    12499
                mstore(0x60, m3)
    12500
                mstore(0x80, m4)
    12501
                mstore(0xa0, m5)
    12502
                mstore(0xc0, m6)
    12503
            }
    12504
        }
    12505
    
                                                    
                                                
    12506
        function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {
    12507
            bytes32 m0;
    12508
            bytes32 m1;
    12509
            bytes32 m2;
    12510
            bytes32 m3;
    12511
            bytes32 m4;
    12512
            bytes32 m5;
    12513
            bytes32 m6;
    12514
            /// @solidity memory-safe-assembly
    12515
            assembly {
    12516
                function writeString(pos, w) {
    12517
                    let length := 0
    12518
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12519
                    mstore(pos, length)
    12520
                    let shift := sub(256, shl(3, length))
    12521
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12522
                }
    12523
                m0 := mload(0x00)
    12524
                m1 := mload(0x20)
    12525
                m2 := mload(0x40)
    12526
                m3 := mload(0x60)
    12527
                m4 := mload(0x80)
    12528
                m5 := mload(0xa0)
    12529
                m6 := mload(0xc0)
    12530
                // Selector of `log(string,uint256,bool,bool)`.
    12531
                mstore(0x00, 0x354c36d6)
    12532
                mstore(0x20, 0x80)
    12533
                mstore(0x40, p1)
    12534
                mstore(0x60, p2)
    12535
                mstore(0x80, p3)
    12536
                writeString(0xa0, p0)
    12537
            }
    12538
            _sendLogPayload(0x1c, 0xc4);
    12539
            /// @solidity memory-safe-assembly
    12540
            assembly {
    12541
                mstore(0x00, m0)
    12542
                mstore(0x20, m1)
    12543
                mstore(0x40, m2)
    12544
                mstore(0x60, m3)
    12545
                mstore(0x80, m4)
    12546
                mstore(0xa0, m5)
    12547
                mstore(0xc0, m6)
    12548
            }
    12549
        }
    12550
    
                                                    
                                                
    12551
        function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    12552
            bytes32 m0;
    12553
            bytes32 m1;
    12554
            bytes32 m2;
    12555
            bytes32 m3;
    12556
            bytes32 m4;
    12557
            bytes32 m5;
    12558
            bytes32 m6;
    12559
            /// @solidity memory-safe-assembly
    12560
            assembly {
    12561
                function writeString(pos, w) {
    12562
                    let length := 0
    12563
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12564
                    mstore(pos, length)
    12565
                    let shift := sub(256, shl(3, length))
    12566
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12567
                }
    12568
                m0 := mload(0x00)
    12569
                m1 := mload(0x20)
    12570
                m2 := mload(0x40)
    12571
                m3 := mload(0x60)
    12572
                m4 := mload(0x80)
    12573
                m5 := mload(0xa0)
    12574
                m6 := mload(0xc0)
    12575
                // Selector of `log(string,uint256,bool,uint256)`.
    12576
                mstore(0x00, 0xe41b6f6f)
    12577
                mstore(0x20, 0x80)
    12578
                mstore(0x40, p1)
    12579
                mstore(0x60, p2)
    12580
                mstore(0x80, p3)
    12581
                writeString(0xa0, p0)
    12582
            }
    12583
            _sendLogPayload(0x1c, 0xc4);
    12584
            /// @solidity memory-safe-assembly
    12585
            assembly {
    12586
                mstore(0x00, m0)
    12587
                mstore(0x20, m1)
    12588
                mstore(0x40, m2)
    12589
                mstore(0x60, m3)
    12590
                mstore(0x80, m4)
    12591
                mstore(0xa0, m5)
    12592
                mstore(0xc0, m6)
    12593
            }
    12594
        }
    12595
    
                                                    
                                                
    12596
        function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    12597
            bytes32 m0;
    12598
            bytes32 m1;
    12599
            bytes32 m2;
    12600
            bytes32 m3;
    12601
            bytes32 m4;
    12602
            bytes32 m5;
    12603
            bytes32 m6;
    12604
            bytes32 m7;
    12605
            bytes32 m8;
    12606
            /// @solidity memory-safe-assembly
    12607
            assembly {
    12608
                function writeString(pos, w) {
    12609
                    let length := 0
    12610
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12611
                    mstore(pos, length)
    12612
                    let shift := sub(256, shl(3, length))
    12613
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12614
                }
    12615
                m0 := mload(0x00)
    12616
                m1 := mload(0x20)
    12617
                m2 := mload(0x40)
    12618
                m3 := mload(0x60)
    12619
                m4 := mload(0x80)
    12620
                m5 := mload(0xa0)
    12621
                m6 := mload(0xc0)
    12622
                m7 := mload(0xe0)
    12623
                m8 := mload(0x100)
    12624
                // Selector of `log(string,uint256,bool,string)`.
    12625
                mstore(0x00, 0xabf73a98)
    12626
                mstore(0x20, 0x80)
    12627
                mstore(0x40, p1)
    12628
                mstore(0x60, p2)
    12629
                mstore(0x80, 0xc0)
    12630
                writeString(0xa0, p0)
    12631
                writeString(0xe0, p3)
    12632
            }
    12633
            _sendLogPayload(0x1c, 0x104);
    12634
            /// @solidity memory-safe-assembly
    12635
            assembly {
    12636
                mstore(0x00, m0)
    12637
                mstore(0x20, m1)
    12638
                mstore(0x40, m2)
    12639
                mstore(0x60, m3)
    12640
                mstore(0x80, m4)
    12641
                mstore(0xa0, m5)
    12642
                mstore(0xc0, m6)
    12643
                mstore(0xe0, m7)
    12644
                mstore(0x100, m8)
    12645
            }
    12646
        }
    12647
    
                                                    
                                                
    12648
        function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {
    12649
            bytes32 m0;
    12650
            bytes32 m1;
    12651
            bytes32 m2;
    12652
            bytes32 m3;
    12653
            bytes32 m4;
    12654
            bytes32 m5;
    12655
            bytes32 m6;
    12656
            /// @solidity memory-safe-assembly
    12657
            assembly {
    12658
                function writeString(pos, w) {
    12659
                    let length := 0
    12660
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12661
                    mstore(pos, length)
    12662
                    let shift := sub(256, shl(3, length))
    12663
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12664
                }
    12665
                m0 := mload(0x00)
    12666
                m1 := mload(0x20)
    12667
                m2 := mload(0x40)
    12668
                m3 := mload(0x60)
    12669
                m4 := mload(0x80)
    12670
                m5 := mload(0xa0)
    12671
                m6 := mload(0xc0)
    12672
                // Selector of `log(string,uint256,uint256,address)`.
    12673
                mstore(0x00, 0xe21de278)
    12674
                mstore(0x20, 0x80)
    12675
                mstore(0x40, p1)
    12676
                mstore(0x60, p2)
    12677
                mstore(0x80, p3)
    12678
                writeString(0xa0, p0)
    12679
            }
    12680
            _sendLogPayload(0x1c, 0xc4);
    12681
            /// @solidity memory-safe-assembly
    12682
            assembly {
    12683
                mstore(0x00, m0)
    12684
                mstore(0x20, m1)
    12685
                mstore(0x40, m2)
    12686
                mstore(0x60, m3)
    12687
                mstore(0x80, m4)
    12688
                mstore(0xa0, m5)
    12689
                mstore(0xc0, m6)
    12690
            }
    12691
        }
    12692
    
                                                    
                                                
    12693
        function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    12694
            bytes32 m0;
    12695
            bytes32 m1;
    12696
            bytes32 m2;
    12697
            bytes32 m3;
    12698
            bytes32 m4;
    12699
            bytes32 m5;
    12700
            bytes32 m6;
    12701
            /// @solidity memory-safe-assembly
    12702
            assembly {
    12703
                function writeString(pos, w) {
    12704
                    let length := 0
    12705
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12706
                    mstore(pos, length)
    12707
                    let shift := sub(256, shl(3, length))
    12708
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12709
                }
    12710
                m0 := mload(0x00)
    12711
                m1 := mload(0x20)
    12712
                m2 := mload(0x40)
    12713
                m3 := mload(0x60)
    12714
                m4 := mload(0x80)
    12715
                m5 := mload(0xa0)
    12716
                m6 := mload(0xc0)
    12717
                // Selector of `log(string,uint256,uint256,bool)`.
    12718
                mstore(0x00, 0x7626db92)
    12719
                mstore(0x20, 0x80)
    12720
                mstore(0x40, p1)
    12721
                mstore(0x60, p2)
    12722
                mstore(0x80, p3)
    12723
                writeString(0xa0, p0)
    12724
            }
    12725
            _sendLogPayload(0x1c, 0xc4);
    12726
            /// @solidity memory-safe-assembly
    12727
            assembly {
    12728
                mstore(0x00, m0)
    12729
                mstore(0x20, m1)
    12730
                mstore(0x40, m2)
    12731
                mstore(0x60, m3)
    12732
                mstore(0x80, m4)
    12733
                mstore(0xa0, m5)
    12734
                mstore(0xc0, m6)
    12735
            }
    12736
        }
    12737
    
                                                    
                                                
    12738
        function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    12739
            bytes32 m0;
    12740
            bytes32 m1;
    12741
            bytes32 m2;
    12742
            bytes32 m3;
    12743
            bytes32 m4;
    12744
            bytes32 m5;
    12745
            bytes32 m6;
    12746
            /// @solidity memory-safe-assembly
    12747
            assembly {
    12748
                function writeString(pos, w) {
    12749
                    let length := 0
    12750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12751
                    mstore(pos, length)
    12752
                    let shift := sub(256, shl(3, length))
    12753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12754
                }
    12755
                m0 := mload(0x00)
    12756
                m1 := mload(0x20)
    12757
                m2 := mload(0x40)
    12758
                m3 := mload(0x60)
    12759
                m4 := mload(0x80)
    12760
                m5 := mload(0xa0)
    12761
                m6 := mload(0xc0)
    12762
                // Selector of `log(string,uint256,uint256,uint256)`.
    12763
                mstore(0x00, 0xa7a87853)
    12764
                mstore(0x20, 0x80)
    12765
                mstore(0x40, p1)
    12766
                mstore(0x60, p2)
    12767
                mstore(0x80, p3)
    12768
                writeString(0xa0, p0)
    12769
            }
    12770
            _sendLogPayload(0x1c, 0xc4);
    12771
            /// @solidity memory-safe-assembly
    12772
            assembly {
    12773
                mstore(0x00, m0)
    12774
                mstore(0x20, m1)
    12775
                mstore(0x40, m2)
    12776
                mstore(0x60, m3)
    12777
                mstore(0x80, m4)
    12778
                mstore(0xa0, m5)
    12779
                mstore(0xc0, m6)
    12780
            }
    12781
        }
    12782
    
                                                    
                                                
    12783
        function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    12784
            bytes32 m0;
    12785
            bytes32 m1;
    12786
            bytes32 m2;
    12787
            bytes32 m3;
    12788
            bytes32 m4;
    12789
            bytes32 m5;
    12790
            bytes32 m6;
    12791
            bytes32 m7;
    12792
            bytes32 m8;
    12793
            /// @solidity memory-safe-assembly
    12794
            assembly {
    12795
                function writeString(pos, w) {
    12796
                    let length := 0
    12797
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12798
                    mstore(pos, length)
    12799
                    let shift := sub(256, shl(3, length))
    12800
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12801
                }
    12802
                m0 := mload(0x00)
    12803
                m1 := mload(0x20)
    12804
                m2 := mload(0x40)
    12805
                m3 := mload(0x60)
    12806
                m4 := mload(0x80)
    12807
                m5 := mload(0xa0)
    12808
                m6 := mload(0xc0)
    12809
                m7 := mload(0xe0)
    12810
                m8 := mload(0x100)
    12811
                // Selector of `log(string,uint256,uint256,string)`.
    12812
                mstore(0x00, 0x854b3496)
    12813
                mstore(0x20, 0x80)
    12814
                mstore(0x40, p1)
    12815
                mstore(0x60, p2)
    12816
                mstore(0x80, 0xc0)
    12817
                writeString(0xa0, p0)
    12818
                writeString(0xe0, p3)
    12819
            }
    12820
            _sendLogPayload(0x1c, 0x104);
    12821
            /// @solidity memory-safe-assembly
    12822
            assembly {
    12823
                mstore(0x00, m0)
    12824
                mstore(0x20, m1)
    12825
                mstore(0x40, m2)
    12826
                mstore(0x60, m3)
    12827
                mstore(0x80, m4)
    12828
                mstore(0xa0, m5)
    12829
                mstore(0xc0, m6)
    12830
                mstore(0xe0, m7)
    12831
                mstore(0x100, m8)
    12832
            }
    12833
        }
    12834
    
                                                    
                                                
    12835
        function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    12836
            bytes32 m0;
    12837
            bytes32 m1;
    12838
            bytes32 m2;
    12839
            bytes32 m3;
    12840
            bytes32 m4;
    12841
            bytes32 m5;
    12842
            bytes32 m6;
    12843
            bytes32 m7;
    12844
            bytes32 m8;
    12845
            /// @solidity memory-safe-assembly
    12846
            assembly {
    12847
                function writeString(pos, w) {
    12848
                    let length := 0
    12849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12850
                    mstore(pos, length)
    12851
                    let shift := sub(256, shl(3, length))
    12852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12853
                }
    12854
                m0 := mload(0x00)
    12855
                m1 := mload(0x20)
    12856
                m2 := mload(0x40)
    12857
                m3 := mload(0x60)
    12858
                m4 := mload(0x80)
    12859
                m5 := mload(0xa0)
    12860
                m6 := mload(0xc0)
    12861
                m7 := mload(0xe0)
    12862
                m8 := mload(0x100)
    12863
                // Selector of `log(string,uint256,string,address)`.
    12864
                mstore(0x00, 0x7c4632a4)
    12865
                mstore(0x20, 0x80)
    12866
                mstore(0x40, p1)
    12867
                mstore(0x60, 0xc0)
    12868
                mstore(0x80, p3)
    12869
                writeString(0xa0, p0)
    12870
                writeString(0xe0, p2)
    12871
            }
    12872
            _sendLogPayload(0x1c, 0x104);
    12873
            /// @solidity memory-safe-assembly
    12874
            assembly {
    12875
                mstore(0x00, m0)
    12876
                mstore(0x20, m1)
    12877
                mstore(0x40, m2)
    12878
                mstore(0x60, m3)
    12879
                mstore(0x80, m4)
    12880
                mstore(0xa0, m5)
    12881
                mstore(0xc0, m6)
    12882
                mstore(0xe0, m7)
    12883
                mstore(0x100, m8)
    12884
            }
    12885
        }
    12886
    
                                                    
                                                
    12887
        function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    12888
            bytes32 m0;
    12889
            bytes32 m1;
    12890
            bytes32 m2;
    12891
            bytes32 m3;
    12892
            bytes32 m4;
    12893
            bytes32 m5;
    12894
            bytes32 m6;
    12895
            bytes32 m7;
    12896
            bytes32 m8;
    12897
            /// @solidity memory-safe-assembly
    12898
            assembly {
    12899
                function writeString(pos, w) {
    12900
                    let length := 0
    12901
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12902
                    mstore(pos, length)
    12903
                    let shift := sub(256, shl(3, length))
    12904
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12905
                }
    12906
                m0 := mload(0x00)
    12907
                m1 := mload(0x20)
    12908
                m2 := mload(0x40)
    12909
                m3 := mload(0x60)
    12910
                m4 := mload(0x80)
    12911
                m5 := mload(0xa0)
    12912
                m6 := mload(0xc0)
    12913
                m7 := mload(0xe0)
    12914
                m8 := mload(0x100)
    12915
                // Selector of `log(string,uint256,string,bool)`.
    12916
                mstore(0x00, 0x7d24491d)
    12917
                mstore(0x20, 0x80)
    12918
                mstore(0x40, p1)
    12919
                mstore(0x60, 0xc0)
    12920
                mstore(0x80, p3)
    12921
                writeString(0xa0, p0)
    12922
                writeString(0xe0, p2)
    12923
            }
    12924
            _sendLogPayload(0x1c, 0x104);
    12925
            /// @solidity memory-safe-assembly
    12926
            assembly {
    12927
                mstore(0x00, m0)
    12928
                mstore(0x20, m1)
    12929
                mstore(0x40, m2)
    12930
                mstore(0x60, m3)
    12931
                mstore(0x80, m4)
    12932
                mstore(0xa0, m5)
    12933
                mstore(0xc0, m6)
    12934
                mstore(0xe0, m7)
    12935
                mstore(0x100, m8)
    12936
            }
    12937
        }
    12938
    
                                                    
                                                
    12939
        function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    12940
            bytes32 m0;
    12941
            bytes32 m1;
    12942
            bytes32 m2;
    12943
            bytes32 m3;
    12944
            bytes32 m4;
    12945
            bytes32 m5;
    12946
            bytes32 m6;
    12947
            bytes32 m7;
    12948
            bytes32 m8;
    12949
            /// @solidity memory-safe-assembly
    12950
            assembly {
    12951
                function writeString(pos, w) {
    12952
                    let length := 0
    12953
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12954
                    mstore(pos, length)
    12955
                    let shift := sub(256, shl(3, length))
    12956
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12957
                }
    12958
                m0 := mload(0x00)
    12959
                m1 := mload(0x20)
    12960
                m2 := mload(0x40)
    12961
                m3 := mload(0x60)
    12962
                m4 := mload(0x80)
    12963
                m5 := mload(0xa0)
    12964
                m6 := mload(0xc0)
    12965
                m7 := mload(0xe0)
    12966
                m8 := mload(0x100)
    12967
                // Selector of `log(string,uint256,string,uint256)`.
    12968
                mstore(0x00, 0xc67ea9d1)
    12969
                mstore(0x20, 0x80)
    12970
                mstore(0x40, p1)
    12971
                mstore(0x60, 0xc0)
    12972
                mstore(0x80, p3)
    12973
                writeString(0xa0, p0)
    12974
                writeString(0xe0, p2)
    12975
            }
    12976
            _sendLogPayload(0x1c, 0x104);
    12977
            /// @solidity memory-safe-assembly
    12978
            assembly {
    12979
                mstore(0x00, m0)
    12980
                mstore(0x20, m1)
    12981
                mstore(0x40, m2)
    12982
                mstore(0x60, m3)
    12983
                mstore(0x80, m4)
    12984
                mstore(0xa0, m5)
    12985
                mstore(0xc0, m6)
    12986
                mstore(0xe0, m7)
    12987
                mstore(0x100, m8)
    12988
            }
    12989
        }
    12990
    
                                                    
                                                
    12991
        function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    12992
            bytes32 m0;
    12993
            bytes32 m1;
    12994
            bytes32 m2;
    12995
            bytes32 m3;
    12996
            bytes32 m4;
    12997
            bytes32 m5;
    12998
            bytes32 m6;
    12999
            bytes32 m7;
    13000
            bytes32 m8;
    13001
            bytes32 m9;
    13002
            bytes32 m10;
    13003
            /// @solidity memory-safe-assembly
    13004
            assembly {
    13005
                function writeString(pos, w) {
    13006
                    let length := 0
    13007
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13008
                    mstore(pos, length)
    13009
                    let shift := sub(256, shl(3, length))
    13010
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13011
                }
    13012
                m0 := mload(0x00)
    13013
                m1 := mload(0x20)
    13014
                m2 := mload(0x40)
    13015
                m3 := mload(0x60)
    13016
                m4 := mload(0x80)
    13017
                m5 := mload(0xa0)
    13018
                m6 := mload(0xc0)
    13019
                m7 := mload(0xe0)
    13020
                m8 := mload(0x100)
    13021
                m9 := mload(0x120)
    13022
                m10 := mload(0x140)
    13023
                // Selector of `log(string,uint256,string,string)`.
    13024
                mstore(0x00, 0x5ab84e1f)
    13025
                mstore(0x20, 0x80)
    13026
                mstore(0x40, p1)
    13027
                mstore(0x60, 0xc0)
    13028
                mstore(0x80, 0x100)
    13029
                writeString(0xa0, p0)
    13030
                writeString(0xe0, p2)
    13031
                writeString(0x120, p3)
    13032
            }
    13033
            _sendLogPayload(0x1c, 0x144);
    13034
            /// @solidity memory-safe-assembly
    13035
            assembly {
    13036
                mstore(0x00, m0)
    13037
                mstore(0x20, m1)
    13038
                mstore(0x40, m2)
    13039
                mstore(0x60, m3)
    13040
                mstore(0x80, m4)
    13041
                mstore(0xa0, m5)
    13042
                mstore(0xc0, m6)
    13043
                mstore(0xe0, m7)
    13044
                mstore(0x100, m8)
    13045
                mstore(0x120, m9)
    13046
                mstore(0x140, m10)
    13047
            }
    13048
        }
    13049
    
                                                    
                                                
    13050
        function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {
    13051
            bytes32 m0;
    13052
            bytes32 m1;
    13053
            bytes32 m2;
    13054
            bytes32 m3;
    13055
            bytes32 m4;
    13056
            bytes32 m5;
    13057
            bytes32 m6;
    13058
            bytes32 m7;
    13059
            bytes32 m8;
    13060
            /// @solidity memory-safe-assembly
    13061
            assembly {
    13062
                function writeString(pos, w) {
    13063
                    let length := 0
    13064
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13065
                    mstore(pos, length)
    13066
                    let shift := sub(256, shl(3, length))
    13067
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13068
                }
    13069
                m0 := mload(0x00)
    13070
                m1 := mload(0x20)
    13071
                m2 := mload(0x40)
    13072
                m3 := mload(0x60)
    13073
                m4 := mload(0x80)
    13074
                m5 := mload(0xa0)
    13075
                m6 := mload(0xc0)
    13076
                m7 := mload(0xe0)
    13077
                m8 := mload(0x100)
    13078
                // Selector of `log(string,string,address,address)`.
    13079
                mstore(0x00, 0x439c7bef)
    13080
                mstore(0x20, 0x80)
    13081
                mstore(0x40, 0xc0)
    13082
                mstore(0x60, p2)
    13083
                mstore(0x80, p3)
    13084
                writeString(0xa0, p0)
    13085
                writeString(0xe0, p1)
    13086
            }
    13087
            _sendLogPayload(0x1c, 0x104);
    13088
            /// @solidity memory-safe-assembly
    13089
            assembly {
    13090
                mstore(0x00, m0)
    13091
                mstore(0x20, m1)
    13092
                mstore(0x40, m2)
    13093
                mstore(0x60, m3)
    13094
                mstore(0x80, m4)
    13095
                mstore(0xa0, m5)
    13096
                mstore(0xc0, m6)
    13097
                mstore(0xe0, m7)
    13098
                mstore(0x100, m8)
    13099
            }
    13100
        }
    13101
    
                                                    
                                                
    13102
        function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {
    13103
            bytes32 m0;
    13104
            bytes32 m1;
    13105
            bytes32 m2;
    13106
            bytes32 m3;
    13107
            bytes32 m4;
    13108
            bytes32 m5;
    13109
            bytes32 m6;
    13110
            bytes32 m7;
    13111
            bytes32 m8;
    13112
            /// @solidity memory-safe-assembly
    13113
            assembly {
    13114
                function writeString(pos, w) {
    13115
                    let length := 0
    13116
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13117
                    mstore(pos, length)
    13118
                    let shift := sub(256, shl(3, length))
    13119
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13120
                }
    13121
                m0 := mload(0x00)
    13122
                m1 := mload(0x20)
    13123
                m2 := mload(0x40)
    13124
                m3 := mload(0x60)
    13125
                m4 := mload(0x80)
    13126
                m5 := mload(0xa0)
    13127
                m6 := mload(0xc0)
    13128
                m7 := mload(0xe0)
    13129
                m8 := mload(0x100)
    13130
                // Selector of `log(string,string,address,bool)`.
    13131
                mstore(0x00, 0x5ccd4e37)
    13132
                mstore(0x20, 0x80)
    13133
                mstore(0x40, 0xc0)
    13134
                mstore(0x60, p2)
    13135
                mstore(0x80, p3)
    13136
                writeString(0xa0, p0)
    13137
                writeString(0xe0, p1)
    13138
            }
    13139
            _sendLogPayload(0x1c, 0x104);
    13140
            /// @solidity memory-safe-assembly
    13141
            assembly {
    13142
                mstore(0x00, m0)
    13143
                mstore(0x20, m1)
    13144
                mstore(0x40, m2)
    13145
                mstore(0x60, m3)
    13146
                mstore(0x80, m4)
    13147
                mstore(0xa0, m5)
    13148
                mstore(0xc0, m6)
    13149
                mstore(0xe0, m7)
    13150
                mstore(0x100, m8)
    13151
            }
    13152
        }
    13153
    
                                                    
                                                
    13154
        function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    13155
            bytes32 m0;
    13156
            bytes32 m1;
    13157
            bytes32 m2;
    13158
            bytes32 m3;
    13159
            bytes32 m4;
    13160
            bytes32 m5;
    13161
            bytes32 m6;
    13162
            bytes32 m7;
    13163
            bytes32 m8;
    13164
            /// @solidity memory-safe-assembly
    13165
            assembly {
    13166
                function writeString(pos, w) {
    13167
                    let length := 0
    13168
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13169
                    mstore(pos, length)
    13170
                    let shift := sub(256, shl(3, length))
    13171
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13172
                }
    13173
                m0 := mload(0x00)
    13174
                m1 := mload(0x20)
    13175
                m2 := mload(0x40)
    13176
                m3 := mload(0x60)
    13177
                m4 := mload(0x80)
    13178
                m5 := mload(0xa0)
    13179
                m6 := mload(0xc0)
    13180
                m7 := mload(0xe0)
    13181
                m8 := mload(0x100)
    13182
                // Selector of `log(string,string,address,uint256)`.
    13183
                mstore(0x00, 0x7cc3c607)
    13184
                mstore(0x20, 0x80)
    13185
                mstore(0x40, 0xc0)
    13186
                mstore(0x60, p2)
    13187
                mstore(0x80, p3)
    13188
                writeString(0xa0, p0)
    13189
                writeString(0xe0, p1)
    13190
            }
    13191
            _sendLogPayload(0x1c, 0x104);
    13192
            /// @solidity memory-safe-assembly
    13193
            assembly {
    13194
                mstore(0x00, m0)
    13195
                mstore(0x20, m1)
    13196
                mstore(0x40, m2)
    13197
                mstore(0x60, m3)
    13198
                mstore(0x80, m4)
    13199
                mstore(0xa0, m5)
    13200
                mstore(0xc0, m6)
    13201
                mstore(0xe0, m7)
    13202
                mstore(0x100, m8)
    13203
            }
    13204
        }
    13205
    
                                                    
                                                
    13206
        function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    13207
            bytes32 m0;
    13208
            bytes32 m1;
    13209
            bytes32 m2;
    13210
            bytes32 m3;
    13211
            bytes32 m4;
    13212
            bytes32 m5;
    13213
            bytes32 m6;
    13214
            bytes32 m7;
    13215
            bytes32 m8;
    13216
            bytes32 m9;
    13217
            bytes32 m10;
    13218
            /// @solidity memory-safe-assembly
    13219
            assembly {
    13220
                function writeString(pos, w) {
    13221
                    let length := 0
    13222
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13223
                    mstore(pos, length)
    13224
                    let shift := sub(256, shl(3, length))
    13225
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13226
                }
    13227
                m0 := mload(0x00)
    13228
                m1 := mload(0x20)
    13229
                m2 := mload(0x40)
    13230
                m3 := mload(0x60)
    13231
                m4 := mload(0x80)
    13232
                m5 := mload(0xa0)
    13233
                m6 := mload(0xc0)
    13234
                m7 := mload(0xe0)
    13235
                m8 := mload(0x100)
    13236
                m9 := mload(0x120)
    13237
                m10 := mload(0x140)
    13238
                // Selector of `log(string,string,address,string)`.
    13239
                mstore(0x00, 0xeb1bff80)
    13240
                mstore(0x20, 0x80)
    13241
                mstore(0x40, 0xc0)
    13242
                mstore(0x60, p2)
    13243
                mstore(0x80, 0x100)
    13244
                writeString(0xa0, p0)
    13245
                writeString(0xe0, p1)
    13246
                writeString(0x120, p3)
    13247
            }
    13248
            _sendLogPayload(0x1c, 0x144);
    13249
            /// @solidity memory-safe-assembly
    13250
            assembly {
    13251
                mstore(0x00, m0)
    13252
                mstore(0x20, m1)
    13253
                mstore(0x40, m2)
    13254
                mstore(0x60, m3)
    13255
                mstore(0x80, m4)
    13256
                mstore(0xa0, m5)
    13257
                mstore(0xc0, m6)
    13258
                mstore(0xe0, m7)
    13259
                mstore(0x100, m8)
    13260
                mstore(0x120, m9)
    13261
                mstore(0x140, m10)
    13262
            }
    13263
        }
    13264
    
                                                    
                                                
    13265
        function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {
    13266
            bytes32 m0;
    13267
            bytes32 m1;
    13268
            bytes32 m2;
    13269
            bytes32 m3;
    13270
            bytes32 m4;
    13271
            bytes32 m5;
    13272
            bytes32 m6;
    13273
            bytes32 m7;
    13274
            bytes32 m8;
    13275
            /// @solidity memory-safe-assembly
    13276
            assembly {
    13277
                function writeString(pos, w) {
    13278
                    let length := 0
    13279
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13280
                    mstore(pos, length)
    13281
                    let shift := sub(256, shl(3, length))
    13282
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13283
                }
    13284
                m0 := mload(0x00)
    13285
                m1 := mload(0x20)
    13286
                m2 := mload(0x40)
    13287
                m3 := mload(0x60)
    13288
                m4 := mload(0x80)
    13289
                m5 := mload(0xa0)
    13290
                m6 := mload(0xc0)
    13291
                m7 := mload(0xe0)
    13292
                m8 := mload(0x100)
    13293
                // Selector of `log(string,string,bool,address)`.
    13294
                mstore(0x00, 0xc371c7db)
    13295
                mstore(0x20, 0x80)
    13296
                mstore(0x40, 0xc0)
    13297
                mstore(0x60, p2)
    13298
                mstore(0x80, p3)
    13299
                writeString(0xa0, p0)
    13300
                writeString(0xe0, p1)
    13301
            }
    13302
            _sendLogPayload(0x1c, 0x104);
    13303
            /// @solidity memory-safe-assembly
    13304
            assembly {
    13305
                mstore(0x00, m0)
    13306
                mstore(0x20, m1)
    13307
                mstore(0x40, m2)
    13308
                mstore(0x60, m3)
    13309
                mstore(0x80, m4)
    13310
                mstore(0xa0, m5)
    13311
                mstore(0xc0, m6)
    13312
                mstore(0xe0, m7)
    13313
                mstore(0x100, m8)
    13314
            }
    13315
        }
    13316
    
                                                    
                                                
    13317
        function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {
    13318
            bytes32 m0;
    13319
            bytes32 m1;
    13320
            bytes32 m2;
    13321
            bytes32 m3;
    13322
            bytes32 m4;
    13323
            bytes32 m5;
    13324
            bytes32 m6;
    13325
            bytes32 m7;
    13326
            bytes32 m8;
    13327
            /// @solidity memory-safe-assembly
    13328
            assembly {
    13329
                function writeString(pos, w) {
    13330
                    let length := 0
    13331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13332
                    mstore(pos, length)
    13333
                    let shift := sub(256, shl(3, length))
    13334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13335
                }
    13336
                m0 := mload(0x00)
    13337
                m1 := mload(0x20)
    13338
                m2 := mload(0x40)
    13339
                m3 := mload(0x60)
    13340
                m4 := mload(0x80)
    13341
                m5 := mload(0xa0)
    13342
                m6 := mload(0xc0)
    13343
                m7 := mload(0xe0)
    13344
                m8 := mload(0x100)
    13345
                // Selector of `log(string,string,bool,bool)`.
    13346
                mstore(0x00, 0x40785869)
    13347
                mstore(0x20, 0x80)
    13348
                mstore(0x40, 0xc0)
    13349
                mstore(0x60, p2)
    13350
                mstore(0x80, p3)
    13351
                writeString(0xa0, p0)
    13352
                writeString(0xe0, p1)
    13353
            }
    13354
            _sendLogPayload(0x1c, 0x104);
    13355
            /// @solidity memory-safe-assembly
    13356
            assembly {
    13357
                mstore(0x00, m0)
    13358
                mstore(0x20, m1)
    13359
                mstore(0x40, m2)
    13360
                mstore(0x60, m3)
    13361
                mstore(0x80, m4)
    13362
                mstore(0xa0, m5)
    13363
                mstore(0xc0, m6)
    13364
                mstore(0xe0, m7)
    13365
                mstore(0x100, m8)
    13366
            }
    13367
        }
    13368
    
                                                    
                                                
    13369
        function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    13370
            bytes32 m0;
    13371
            bytes32 m1;
    13372
            bytes32 m2;
    13373
            bytes32 m3;
    13374
            bytes32 m4;
    13375
            bytes32 m5;
    13376
            bytes32 m6;
    13377
            bytes32 m7;
    13378
            bytes32 m8;
    13379
            /// @solidity memory-safe-assembly
    13380
            assembly {
    13381
                function writeString(pos, w) {
    13382
                    let length := 0
    13383
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13384
                    mstore(pos, length)
    13385
                    let shift := sub(256, shl(3, length))
    13386
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13387
                }
    13388
                m0 := mload(0x00)
    13389
                m1 := mload(0x20)
    13390
                m2 := mload(0x40)
    13391
                m3 := mload(0x60)
    13392
                m4 := mload(0x80)
    13393
                m5 := mload(0xa0)
    13394
                m6 := mload(0xc0)
    13395
                m7 := mload(0xe0)
    13396
                m8 := mload(0x100)
    13397
                // Selector of `log(string,string,bool,uint256)`.
    13398
                mstore(0x00, 0xd6aefad2)
    13399
                mstore(0x20, 0x80)
    13400
                mstore(0x40, 0xc0)
    13401
                mstore(0x60, p2)
    13402
                mstore(0x80, p3)
    13403
                writeString(0xa0, p0)
    13404
                writeString(0xe0, p1)
    13405
            }
    13406
            _sendLogPayload(0x1c, 0x104);
    13407
            /// @solidity memory-safe-assembly
    13408
            assembly {
    13409
                mstore(0x00, m0)
    13410
                mstore(0x20, m1)
    13411
                mstore(0x40, m2)
    13412
                mstore(0x60, m3)
    13413
                mstore(0x80, m4)
    13414
                mstore(0xa0, m5)
    13415
                mstore(0xc0, m6)
    13416
                mstore(0xe0, m7)
    13417
                mstore(0x100, m8)
    13418
            }
    13419
        }
    13420
    
                                                    
                                                
    13421
        function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    13422
            bytes32 m0;
    13423
            bytes32 m1;
    13424
            bytes32 m2;
    13425
            bytes32 m3;
    13426
            bytes32 m4;
    13427
            bytes32 m5;
    13428
            bytes32 m6;
    13429
            bytes32 m7;
    13430
            bytes32 m8;
    13431
            bytes32 m9;
    13432
            bytes32 m10;
    13433
            /// @solidity memory-safe-assembly
    13434
            assembly {
    13435
                function writeString(pos, w) {
    13436
                    let length := 0
    13437
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13438
                    mstore(pos, length)
    13439
                    let shift := sub(256, shl(3, length))
    13440
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13441
                }
    13442
                m0 := mload(0x00)
    13443
                m1 := mload(0x20)
    13444
                m2 := mload(0x40)
    13445
                m3 := mload(0x60)
    13446
                m4 := mload(0x80)
    13447
                m5 := mload(0xa0)
    13448
                m6 := mload(0xc0)
    13449
                m7 := mload(0xe0)
    13450
                m8 := mload(0x100)
    13451
                m9 := mload(0x120)
    13452
                m10 := mload(0x140)
    13453
                // Selector of `log(string,string,bool,string)`.
    13454
                mstore(0x00, 0x5e84b0ea)
    13455
                mstore(0x20, 0x80)
    13456
                mstore(0x40, 0xc0)
    13457
                mstore(0x60, p2)
    13458
                mstore(0x80, 0x100)
    13459
                writeString(0xa0, p0)
    13460
                writeString(0xe0, p1)
    13461
                writeString(0x120, p3)
    13462
            }
    13463
            _sendLogPayload(0x1c, 0x144);
    13464
            /// @solidity memory-safe-assembly
    13465
            assembly {
    13466
                mstore(0x00, m0)
    13467
                mstore(0x20, m1)
    13468
                mstore(0x40, m2)
    13469
                mstore(0x60, m3)
    13470
                mstore(0x80, m4)
    13471
                mstore(0xa0, m5)
    13472
                mstore(0xc0, m6)
    13473
                mstore(0xe0, m7)
    13474
                mstore(0x100, m8)
    13475
                mstore(0x120, m9)
    13476
                mstore(0x140, m10)
    13477
            }
    13478
        }
    13479
    
                                                    
                                                
    13480
        function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    13481
            bytes32 m0;
    13482
            bytes32 m1;
    13483
            bytes32 m2;
    13484
            bytes32 m3;
    13485
            bytes32 m4;
    13486
            bytes32 m5;
    13487
            bytes32 m6;
    13488
            bytes32 m7;
    13489
            bytes32 m8;
    13490
            /// @solidity memory-safe-assembly
    13491
            assembly {
    13492
                function writeString(pos, w) {
    13493
                    let length := 0
    13494
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13495
                    mstore(pos, length)
    13496
                    let shift := sub(256, shl(3, length))
    13497
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13498
                }
    13499
                m0 := mload(0x00)
    13500
                m1 := mload(0x20)
    13501
                m2 := mload(0x40)
    13502
                m3 := mload(0x60)
    13503
                m4 := mload(0x80)
    13504
                m5 := mload(0xa0)
    13505
                m6 := mload(0xc0)
    13506
                m7 := mload(0xe0)
    13507
                m8 := mload(0x100)
    13508
                // Selector of `log(string,string,uint256,address)`.
    13509
                mstore(0x00, 0x1023f7b2)
    13510
                mstore(0x20, 0x80)
    13511
                mstore(0x40, 0xc0)
    13512
                mstore(0x60, p2)
    13513
                mstore(0x80, p3)
    13514
                writeString(0xa0, p0)
    13515
                writeString(0xe0, p1)
    13516
            }
    13517
            _sendLogPayload(0x1c, 0x104);
    13518
            /// @solidity memory-safe-assembly
    13519
            assembly {
    13520
                mstore(0x00, m0)
    13521
                mstore(0x20, m1)
    13522
                mstore(0x40, m2)
    13523
                mstore(0x60, m3)
    13524
                mstore(0x80, m4)
    13525
                mstore(0xa0, m5)
    13526
                mstore(0xc0, m6)
    13527
                mstore(0xe0, m7)
    13528
                mstore(0x100, m8)
    13529
            }
    13530
        }
    13531
    
                                                    
                                                
    13532
        function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    13533
            bytes32 m0;
    13534
            bytes32 m1;
    13535
            bytes32 m2;
    13536
            bytes32 m3;
    13537
            bytes32 m4;
    13538
            bytes32 m5;
    13539
            bytes32 m6;
    13540
            bytes32 m7;
    13541
            bytes32 m8;
    13542
            /// @solidity memory-safe-assembly
    13543
            assembly {
    13544
                function writeString(pos, w) {
    13545
                    let length := 0
    13546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13547
                    mstore(pos, length)
    13548
                    let shift := sub(256, shl(3, length))
    13549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13550
                }
    13551
                m0 := mload(0x00)
    13552
                m1 := mload(0x20)
    13553
                m2 := mload(0x40)
    13554
                m3 := mload(0x60)
    13555
                m4 := mload(0x80)
    13556
                m5 := mload(0xa0)
    13557
                m6 := mload(0xc0)
    13558
                m7 := mload(0xe0)
    13559
                m8 := mload(0x100)
    13560
                // Selector of `log(string,string,uint256,bool)`.
    13561
                mstore(0x00, 0xc3a8a654)
    13562
                mstore(0x20, 0x80)
    13563
                mstore(0x40, 0xc0)
    13564
                mstore(0x60, p2)
    13565
                mstore(0x80, p3)
    13566
                writeString(0xa0, p0)
    13567
                writeString(0xe0, p1)
    13568
            }
    13569
            _sendLogPayload(0x1c, 0x104);
    13570
            /// @solidity memory-safe-assembly
    13571
            assembly {
    13572
                mstore(0x00, m0)
    13573
                mstore(0x20, m1)
    13574
                mstore(0x40, m2)
    13575
                mstore(0x60, m3)
    13576
                mstore(0x80, m4)
    13577
                mstore(0xa0, m5)
    13578
                mstore(0xc0, m6)
    13579
                mstore(0xe0, m7)
    13580
                mstore(0x100, m8)
    13581
            }
    13582
        }
    13583
    
                                                    
                                                
    13584
        function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    13585
            bytes32 m0;
    13586
            bytes32 m1;
    13587
            bytes32 m2;
    13588
            bytes32 m3;
    13589
            bytes32 m4;
    13590
            bytes32 m5;
    13591
            bytes32 m6;
    13592
            bytes32 m7;
    13593
            bytes32 m8;
    13594
            /// @solidity memory-safe-assembly
    13595
            assembly {
    13596
                function writeString(pos, w) {
    13597
                    let length := 0
    13598
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13599
                    mstore(pos, length)
    13600
                    let shift := sub(256, shl(3, length))
    13601
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13602
                }
    13603
                m0 := mload(0x00)
    13604
                m1 := mload(0x20)
    13605
                m2 := mload(0x40)
    13606
                m3 := mload(0x60)
    13607
                m4 := mload(0x80)
    13608
                m5 := mload(0xa0)
    13609
                m6 := mload(0xc0)
    13610
                m7 := mload(0xe0)
    13611
                m8 := mload(0x100)
    13612
                // Selector of `log(string,string,uint256,uint256)`.
    13613
                mstore(0x00, 0xf45d7d2c)
    13614
                mstore(0x20, 0x80)
    13615
                mstore(0x40, 0xc0)
    13616
                mstore(0x60, p2)
    13617
                mstore(0x80, p3)
    13618
                writeString(0xa0, p0)
    13619
                writeString(0xe0, p1)
    13620
            }
    13621
            _sendLogPayload(0x1c, 0x104);
    13622
            /// @solidity memory-safe-assembly
    13623
            assembly {
    13624
                mstore(0x00, m0)
    13625
                mstore(0x20, m1)
    13626
                mstore(0x40, m2)
    13627
                mstore(0x60, m3)
    13628
                mstore(0x80, m4)
    13629
                mstore(0xa0, m5)
    13630
                mstore(0xc0, m6)
    13631
                mstore(0xe0, m7)
    13632
                mstore(0x100, m8)
    13633
            }
    13634
        }
    13635
    
                                                    
                                                
    13636
        function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    13637
            bytes32 m0;
    13638
            bytes32 m1;
    13639
            bytes32 m2;
    13640
            bytes32 m3;
    13641
            bytes32 m4;
    13642
            bytes32 m5;
    13643
            bytes32 m6;
    13644
            bytes32 m7;
    13645
            bytes32 m8;
    13646
            bytes32 m9;
    13647
            bytes32 m10;
    13648
            /// @solidity memory-safe-assembly
    13649
            assembly {
    13650
                function writeString(pos, w) {
    13651
                    let length := 0
    13652
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13653
                    mstore(pos, length)
    13654
                    let shift := sub(256, shl(3, length))
    13655
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13656
                }
    13657
                m0 := mload(0x00)
    13658
                m1 := mload(0x20)
    13659
                m2 := mload(0x40)
    13660
                m3 := mload(0x60)
    13661
                m4 := mload(0x80)
    13662
                m5 := mload(0xa0)
    13663
                m6 := mload(0xc0)
    13664
                m7 := mload(0xe0)
    13665
                m8 := mload(0x100)
    13666
                m9 := mload(0x120)
    13667
                m10 := mload(0x140)
    13668
                // Selector of `log(string,string,uint256,string)`.
    13669
                mstore(0x00, 0x5d1a971a)
    13670
                mstore(0x20, 0x80)
    13671
                mstore(0x40, 0xc0)
    13672
                mstore(0x60, p2)
    13673
                mstore(0x80, 0x100)
    13674
                writeString(0xa0, p0)
    13675
                writeString(0xe0, p1)
    13676
                writeString(0x120, p3)
    13677
            }
    13678
            _sendLogPayload(0x1c, 0x144);
    13679
            /// @solidity memory-safe-assembly
    13680
            assembly {
    13681
                mstore(0x00, m0)
    13682
                mstore(0x20, m1)
    13683
                mstore(0x40, m2)
    13684
                mstore(0x60, m3)
    13685
                mstore(0x80, m4)
    13686
                mstore(0xa0, m5)
    13687
                mstore(0xc0, m6)
    13688
                mstore(0xe0, m7)
    13689
                mstore(0x100, m8)
    13690
                mstore(0x120, m9)
    13691
                mstore(0x140, m10)
    13692
            }
    13693
        }
    13694
    
                                                    
                                                
    13695
        function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    13696
            bytes32 m0;
    13697
            bytes32 m1;
    13698
            bytes32 m2;
    13699
            bytes32 m3;
    13700
            bytes32 m4;
    13701
            bytes32 m5;
    13702
            bytes32 m6;
    13703
            bytes32 m7;
    13704
            bytes32 m8;
    13705
            bytes32 m9;
    13706
            bytes32 m10;
    13707
            /// @solidity memory-safe-assembly
    13708
            assembly {
    13709
                function writeString(pos, w) {
    13710
                    let length := 0
    13711
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13712
                    mstore(pos, length)
    13713
                    let shift := sub(256, shl(3, length))
    13714
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13715
                }
    13716
                m0 := mload(0x00)
    13717
                m1 := mload(0x20)
    13718
                m2 := mload(0x40)
    13719
                m3 := mload(0x60)
    13720
                m4 := mload(0x80)
    13721
                m5 := mload(0xa0)
    13722
                m6 := mload(0xc0)
    13723
                m7 := mload(0xe0)
    13724
                m8 := mload(0x100)
    13725
                m9 := mload(0x120)
    13726
                m10 := mload(0x140)
    13727
                // Selector of `log(string,string,string,address)`.
    13728
                mstore(0x00, 0x6d572f44)
    13729
                mstore(0x20, 0x80)
    13730
                mstore(0x40, 0xc0)
    13731
                mstore(0x60, 0x100)
    13732
                mstore(0x80, p3)
    13733
                writeString(0xa0, p0)
    13734
                writeString(0xe0, p1)
    13735
                writeString(0x120, p2)
    13736
            }
    13737
            _sendLogPayload(0x1c, 0x144);
    13738
            /// @solidity memory-safe-assembly
    13739
            assembly {
    13740
                mstore(0x00, m0)
    13741
                mstore(0x20, m1)
    13742
                mstore(0x40, m2)
    13743
                mstore(0x60, m3)
    13744
                mstore(0x80, m4)
    13745
                mstore(0xa0, m5)
    13746
                mstore(0xc0, m6)
    13747
                mstore(0xe0, m7)
    13748
                mstore(0x100, m8)
    13749
                mstore(0x120, m9)
    13750
                mstore(0x140, m10)
    13751
            }
    13752
        }
    13753
    
                                                    
                                                
    13754
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    13755
            bytes32 m0;
    13756
            bytes32 m1;
    13757
            bytes32 m2;
    13758
            bytes32 m3;
    13759
            bytes32 m4;
    13760
            bytes32 m5;
    13761
            bytes32 m6;
    13762
            bytes32 m7;
    13763
            bytes32 m8;
    13764
            bytes32 m9;
    13765
            bytes32 m10;
    13766
            /// @solidity memory-safe-assembly
    13767
            assembly {
    13768
                function writeString(pos, w) {
    13769
                    let length := 0
    13770
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13771
                    mstore(pos, length)
    13772
                    let shift := sub(256, shl(3, length))
    13773
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13774
                }
    13775
                m0 := mload(0x00)
    13776
                m1 := mload(0x20)
    13777
                m2 := mload(0x40)
    13778
                m3 := mload(0x60)
    13779
                m4 := mload(0x80)
    13780
                m5 := mload(0xa0)
    13781
                m6 := mload(0xc0)
    13782
                m7 := mload(0xe0)
    13783
                m8 := mload(0x100)
    13784
                m9 := mload(0x120)
    13785
                m10 := mload(0x140)
    13786
                // Selector of `log(string,string,string,bool)`.
    13787
                mstore(0x00, 0x2c1754ed)
    13788
                mstore(0x20, 0x80)
    13789
                mstore(0x40, 0xc0)
    13790
                mstore(0x60, 0x100)
    13791
                mstore(0x80, p3)
    13792
                writeString(0xa0, p0)
    13793
                writeString(0xe0, p1)
    13794
                writeString(0x120, p2)
    13795
            }
    13796
            _sendLogPayload(0x1c, 0x144);
    13797
            /// @solidity memory-safe-assembly
    13798
            assembly {
    13799
                mstore(0x00, m0)
    13800
                mstore(0x20, m1)
    13801
                mstore(0x40, m2)
    13802
                mstore(0x60, m3)
    13803
                mstore(0x80, m4)
    13804
                mstore(0xa0, m5)
    13805
                mstore(0xc0, m6)
    13806
                mstore(0xe0, m7)
    13807
                mstore(0x100, m8)
    13808
                mstore(0x120, m9)
    13809
                mstore(0x140, m10)
    13810
            }
    13811
        }
    13812
    
                                                    
                                                
    13813
        function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    13814
            bytes32 m0;
    13815
            bytes32 m1;
    13816
            bytes32 m2;
    13817
            bytes32 m3;
    13818
            bytes32 m4;
    13819
            bytes32 m5;
    13820
            bytes32 m6;
    13821
            bytes32 m7;
    13822
            bytes32 m8;
    13823
            bytes32 m9;
    13824
            bytes32 m10;
    13825
            /// @solidity memory-safe-assembly
    13826
            assembly {
    13827
                function writeString(pos, w) {
    13828
                    let length := 0
    13829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13830
                    mstore(pos, length)
    13831
                    let shift := sub(256, shl(3, length))
    13832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13833
                }
    13834
                m0 := mload(0x00)
    13835
                m1 := mload(0x20)
    13836
                m2 := mload(0x40)
    13837
                m3 := mload(0x60)
    13838
                m4 := mload(0x80)
    13839
                m5 := mload(0xa0)
    13840
                m6 := mload(0xc0)
    13841
                m7 := mload(0xe0)
    13842
                m8 := mload(0x100)
    13843
                m9 := mload(0x120)
    13844
                m10 := mload(0x140)
    13845
                // Selector of `log(string,string,string,uint256)`.
    13846
                mstore(0x00, 0x8eafb02b)
    13847
                mstore(0x20, 0x80)
    13848
                mstore(0x40, 0xc0)
    13849
                mstore(0x60, 0x100)
    13850
                mstore(0x80, p3)
    13851
                writeString(0xa0, p0)
    13852
                writeString(0xe0, p1)
    13853
                writeString(0x120, p2)
    13854
            }
    13855
            _sendLogPayload(0x1c, 0x144);
    13856
            /// @solidity memory-safe-assembly
    13857
            assembly {
    13858
                mstore(0x00, m0)
    13859
                mstore(0x20, m1)
    13860
                mstore(0x40, m2)
    13861
                mstore(0x60, m3)
    13862
                mstore(0x80, m4)
    13863
                mstore(0xa0, m5)
    13864
                mstore(0xc0, m6)
    13865
                mstore(0xe0, m7)
    13866
                mstore(0x100, m8)
    13867
                mstore(0x120, m9)
    13868
                mstore(0x140, m10)
    13869
            }
    13870
        }
    13871
    
                                                    
                                                
    13872
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    13873
            bytes32 m0;
    13874
            bytes32 m1;
    13875
            bytes32 m2;
    13876
            bytes32 m3;
    13877
            bytes32 m4;
    13878
            bytes32 m5;
    13879
            bytes32 m6;
    13880
            bytes32 m7;
    13881
            bytes32 m8;
    13882
            bytes32 m9;
    13883
            bytes32 m10;
    13884
            bytes32 m11;
    13885
            bytes32 m12;
    13886
            /// @solidity memory-safe-assembly
    13887
            assembly {
    13888
                function writeString(pos, w) {
    13889
                    let length := 0
    13890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13891
                    mstore(pos, length)
    13892
                    let shift := sub(256, shl(3, length))
    13893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13894
                }
    13895
                m0 := mload(0x00)
    13896
                m1 := mload(0x20)
    13897
                m2 := mload(0x40)
    13898
                m3 := mload(0x60)
    13899
                m4 := mload(0x80)
    13900
                m5 := mload(0xa0)
    13901
                m6 := mload(0xc0)
    13902
                m7 := mload(0xe0)
    13903
                m8 := mload(0x100)
    13904
                m9 := mload(0x120)
    13905
                m10 := mload(0x140)
    13906
                m11 := mload(0x160)
    13907
                m12 := mload(0x180)
    13908
                // Selector of `log(string,string,string,string)`.
    13909
                mstore(0x00, 0xde68f20a)
    13910
                mstore(0x20, 0x80)
    13911
                mstore(0x40, 0xc0)
    13912
                mstore(0x60, 0x100)
    13913
                mstore(0x80, 0x140)
    13914
                writeString(0xa0, p0)
    13915
                writeString(0xe0, p1)
    13916
                writeString(0x120, p2)
    13917
                writeString(0x160, p3)
    13918
            }
    13919
            _sendLogPayload(0x1c, 0x184);
    13920
            /// @solidity memory-safe-assembly
    13921
            assembly {
    13922
                mstore(0x00, m0)
    13923
                mstore(0x20, m1)
    13924
                mstore(0x40, m2)
    13925
                mstore(0x60, m3)
    13926
                mstore(0x80, m4)
    13927
                mstore(0xa0, m5)
    13928
                mstore(0xc0, m6)
    13929
                mstore(0xe0, m7)
    13930
                mstore(0x100, m8)
    13931
                mstore(0x120, m9)
    13932
                mstore(0x140, m10)
    13933
                mstore(0x160, m11)
    13934
                mstore(0x180, m12)
    13935
            }
    13936
        }
    13937
    }
    13938
    
                                                    
                                                
    34.9% src/OrderBook.sol
    Lines covered: 44 / 126 (34.9%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    /**
    5
     *  ░▒▓██████▓▒░░▒▓███████▓▒░░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░ ░▒▓██████▓▒░░▒▓█▓▒░░▒▓█▓▒░
    6
     * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░
    7
     * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░
    8
     * ░▒▓█▓▒░░▒▓█▓▒░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░▒▓██████▓▒░ ░▒▓███████▓▒░       ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓███████▓▒░
    9
     * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░
    10
     * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░
    11
     *  ░▒▓██████▓▒░░▒▓█▓▒░░▒▓█▓▒░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░ ░▒▓██████▓▒░░▒▓█▓▒░░▒▓█▓▒░
    12
     */
    13
    import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    14
    import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    15
    import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
    16
    import {Strings} from "@openzeppelin/contracts/utils/Strings.sol"; // For number to string conversion
    17
    
                                                    
                                                
    18
    /**
    19
     * @title OrderBook
    20
     * @author Chukwubuike Victory Chime yeahChibyke @github.com
    21
     * @notice This contract is built to mirror the way order-books operate in TradFi, but on DeFi, as close as possible
    22
     */
    23
    contract OrderBook is Ownable {
    24
        using SafeERC20 for IERC20;
    25
        using Strings for uint256;
    26
    
                                                    
                                                
    27
        struct Order {
    28
            uint256 id;
    29
            address seller;
    30
            address tokenToSell; // Address of wETH, wBTC, or wSOL
    31
            uint256 amountToSell; // Amount of tokenToSell
    32
            uint256 priceInUSDC; // Total USDC price for the entire amountToSell
    33
            uint256 deadlineTimestamp; // Block timestamp after which the order expires
    34
            bool isActive; // Flag indicating if the order is available to be bought
    35
        }
    36
    
                                                    
                                                
    37
        // --- Constants ---
    38
    ✓ 50.0K
        uint256 public constant MAX_DEADLINE_DURATION = 3 days; // Max duration from now for a deadline
    39
    ✓ 50.0K
        uint256 public constant FEE = 3; // 3%
    40
    ✓ 50.0K
        uint256 public constant PRECISION = 100;
    41
    
                                                    
                                                
    42
        // --- State Variables ---
    43
        IERC20 public immutable iWETH;
    44
        IERC20 public immutable iWBTC;
    45
        IERC20 public immutable iWSOL;
    46
        IERC20 public immutable iUSDC;
    47
    
                                                    
                                                
    48
        mapping(address => bool) public allowedSellToken;
    49
    
                                                    
                                                
    50
        mapping(uint256 => Order) public orders;
    51
        uint256 private _nextOrderId;
    52
        uint256 public totalFees;
    53
    
                                                    
                                                
    54
        // --- Events ---
    55
        event OrderCreated(
    56
            uint256 indexed orderId,
    57
            address indexed seller,
    58
            address indexed tokenToSell,
    59
            uint256 amountToSell,
    60
            uint256 priceInUSDC,
    61
            uint256 deadlineTimestamp
    62
        );
    63
        event OrderAmended(
    64
            uint256 indexed orderId, uint256 newAmountToSell, uint256 newPriceInUSDC, uint256 newDeadlineTimestamp
    65
        );
    66
        event OrderCancelled(uint256 indexed orderId, address indexed seller);
    67
        event OrderFilled(uint256 indexed orderId, address indexed buyer, address indexed seller);
    68
        event TokenAllowed(address indexed token, bool indexed status);
    69
        event EmergencyWithdrawal(address indexed token, uint256 indexed amount, address indexed receiver);
    70
        event FeesWithdrawn(address indexed receiver);
    71
    
                                                    
                                                
    72
        // --- Errors ---
    73
        error OrderNotFound();
    74
        error NotOrderSeller();
    75
        error OrderNotActive();
    76
        error OrderExpired();
    77
        error OrderAlreadyInactive();
    78
        error InvalidToken();
    79
        error InvalidAmount();
    80
        error InvalidPrice();
    81
        error InvalidDeadline();
    82
        error InvalidAddress();
    83
    
                                                    
                                                
    84
        // --- Constructor ---
    85
    ✓ 1
        constructor(address _weth, address _wbtc, address _wsol, address _usdc, address _owner) Ownable(_owner) {
    86
    ✓ 1
            if (_weth == address(0) || _wbtc == address(0) || _wsol == address(0) || _usdc == address(0)) {
    87
                revert InvalidToken();
    88
            }
    89
    ✓ 1
            if (_owner == address(0)) {
    90
                revert InvalidAddress();
    91
            }
    92
    
                                                    
                                                
    93
    ✓ 1
            iWETH = IERC20(_weth);
    94
    ✓ 1
            allowedSellToken[_weth] = true;
    95
    
                                                    
                                                
    96
    ✓ 1
            iWBTC = IERC20(_wbtc);
    97
    ✓ 1
            allowedSellToken[_wbtc] = true;
    98
    
                                                    
                                                
    99
    ✓ 1
            iWSOL = IERC20(_wsol);
    100
    ✓ 1
            allowedSellToken[_wsol] = true;
    101
    
                                                    
                                                
    102
    ✓ 1
            iUSDC = IERC20(_usdc);
    103
    
                                                    
                                                
    104
    ✓ 1
            _nextOrderId = 1; // Start order IDs from 1
    105
        }
    106
    
                                                    
                                                
    107
        function createSellOrder(
    108
            address _tokenToSell,
    109
            uint256 _amountToSell,
    110
            uint256 _priceInUSDC,
    111
            uint256 _deadlineDuration
    112
    ✓ 50.0K
        ) public returns (uint256) {
    113
    ✓ 50.0K
            if (!allowedSellToken[_tokenToSell]) revert InvalidToken();
    114
    ✓ 50.0K
            if (_amountToSell == 0) revert InvalidAmount();
    115
    ✓ 50.0K
            if (_priceInUSDC == 0) revert InvalidPrice();
    116
    ✓ 50.0K
            if (_deadlineDuration == 0 || _deadlineDuration > MAX_DEADLINE_DURATION) revert InvalidDeadline();
    117
    
                                                    
                                                
    118
    ✓ 50.0K
            uint256 deadlineTimestamp = block.timestamp + _deadlineDuration;
    119
    ✓ 50.0K
            uint256 orderId = _nextOrderId++;
    120
    
                                                    
                                                
    121
    ✓ 50.0K
            IERC20(_tokenToSell).safeTransferFrom(msg.sender, address(this), _amountToSell);
    122
    
                                                    
                                                
    123
            // Store the order
    124
    ✓ 50.0K
            orders[orderId] = Order({
    125
    ✓ 50.0K
                id: orderId,
    126
    ✓ 50.0K
                seller: msg.sender,
    127
    ✓ 50.0K
                tokenToSell: _tokenToSell,
    128
    ✓ 50.0K
                amountToSell: _amountToSell,
    129
    ✓ 50.0K
                priceInUSDC: _priceInUSDC,
    130
    ✓ 50.0K
                deadlineTimestamp: deadlineTimestamp,
    131
    ✓ 50.0K
                isActive: true
    132
            });
    133
    
                                                    
                                                
    134
    ✓ 50.0K
            emit OrderCreated(orderId, msg.sender, _tokenToSell, _amountToSell, _priceInUSDC, deadlineTimestamp);
    135
    ✓ 50.0K
            return orderId;
    136
        }
    137
    
                                                    
                                                
    138
        function amendSellOrder(
    139
            uint256 _orderId,
    140
            uint256 _newAmountToSell,
    141
            uint256 _newPriceInUSDC,
    142
            uint256 _newDeadlineDuration
    143
        ) public {
    144
            Order storage order = orders[_orderId];
    145
    
                                                    
                                                
    146
            // Validation checks
    147
            if (order.seller == address(0)) revert OrderNotFound(); // Check if order exists
    148
            if (order.seller != msg.sender) revert NotOrderSeller();
    149
            if (!order.isActive) revert OrderAlreadyInactive();
    150
            if (block.timestamp >= order.deadlineTimestamp) revert OrderExpired(); // Cannot amend expired order
    151
            if (_newAmountToSell == 0) revert InvalidAmount();
    152
            if (_newPriceInUSDC == 0) revert InvalidPrice();
    153
            if (_newDeadlineDuration == 0 || _newDeadlineDuration > MAX_DEADLINE_DURATION) revert InvalidDeadline();
    154
    
                                                    
                                                
    155
            uint256 newDeadlineTimestamp = block.timestamp + _newDeadlineDuration;
    156
            IERC20 token = IERC20(order.tokenToSell);
    157
    
                                                    
                                                
    158
            // Handle token amount changes
    159
            if (_newAmountToSell > order.amountToSell) {
    160
                // Increasing amount: Transfer additional tokens from seller
    161
                uint256 diff = _newAmountToSell - order.amountToSell;
    162
                token.safeTransferFrom(msg.sender, address(this), diff);
    163
            } else if (_newAmountToSell < order.amountToSell) {
    164
                // Decreasing amount: Transfer excess tokens back to seller
    165
                uint256 diff = order.amountToSell - _newAmountToSell;
    166
                token.safeTransfer(order.seller, diff);
    167
            }
    168
    
                                                    
                                                
    169
            // Update order details
    170
            order.amountToSell = _newAmountToSell;
    171
            order.priceInUSDC = _newPriceInUSDC;
    172
            order.deadlineTimestamp = newDeadlineTimestamp;
    173
    
                                                    
                                                
    174
            emit OrderAmended(_orderId, _newAmountToSell, _newPriceInUSDC, newDeadlineTimestamp);
    175
        }
    176
    
                                                    
                                                
    177
        function cancelSellOrder(uint256 _orderId) public {
    178
            Order storage order = orders[_orderId];
    179
    
                                                    
                                                
    180
            // Validation checks
    181
            if (order.seller == address(0)) revert OrderNotFound();
    182
            if (order.seller != msg.sender) revert NotOrderSeller();
    183
            if (!order.isActive) revert OrderAlreadyInactive(); // Already inactive (filled or cancelled)
    184
    
                                                    
                                                
    185
            // Mark as inactive
    186
            order.isActive = false;
    187
    
                                                    
                                                
    188
            // Return locked tokens to the seller
    189
            IERC20(order.tokenToSell).safeTransfer(order.seller, order.amountToSell);
    190
    
                                                    
                                                
    191
            emit OrderCancelled(_orderId, order.seller);
    192
        }
    193
    
                                                    
                                                
    194
        function buyOrder(uint256 _orderId) public {
    195
    ✓ 50.0K
            Order storage order = orders[_orderId];
    196
    
                                                    
                                                
    197
            // Validation checks
    198
    ✓ 50.0K
            if (order.seller == address(0)) revert OrderNotFound();
    199
    ✓ 50.0K
            if (!order.isActive) revert OrderNotActive();
    200
    ✓ 50.0K
            if (block.timestamp >= order.deadlineTimestamp) revert OrderExpired();
    201
    
                                                    
                                                
    202
    ✓ 50.0K
            order.isActive = false;
    203
    ✓ 50.0K
            uint256 protocolFee = (order.priceInUSDC * FEE) / PRECISION;
    204
    ✓ 50.0K
            uint256 sellerReceives = order.priceInUSDC - protocolFee;
    205
    
                                                    
                                                
    206
    ✓ 50.0K
            iUSDC.safeTransferFrom(msg.sender, address(this), protocolFee);
    207
    ✓ 50.0K
            iUSDC.safeTransferFrom(msg.sender, order.seller, sellerReceives);
    208
    ✓ 50.0K
            IERC20(order.tokenToSell).safeTransfer(msg.sender, order.amountToSell);
    209
    
                                                    
                                                
    210
    ✓ 50.0K
            totalFees += protocolFee;
    211
    
                                                    
                                                
    212
    ✓ 50.0K
            emit OrderFilled(_orderId, msg.sender, order.seller);
    213
        }
    214
    
                                                    
                                                
    215
        function getOrder(uint256 _orderId) public view returns (Order memory orderDetails) {
    216
            if (orders[_orderId].seller == address(0)) revert OrderNotFound();
    217
            orderDetails = orders[_orderId];
    218
        }
    219
    
                                                    
                                                
    220
        function getOrderDetailsString(uint256 _orderId) public view returns (string memory details) {
    221
            Order storage order = orders[_orderId];
    222
            if (order.seller == address(0)) revert OrderNotFound(); // Check if order exists
    223
    
                                                    
                                                
    224
            string memory tokenSymbol;
    225
            if (order.tokenToSell == address(iWETH)) {
    226
                tokenSymbol = "wETH";
    227
            } else if (order.tokenToSell == address(iWBTC)) {
    228
                tokenSymbol = "wBTC";
    229
            } else if (order.tokenToSell == address(iWSOL)) {
    230
                tokenSymbol = "wSOL";
    231
            }
    232
    
                                                    
                                                
    233
            string memory status = order.isActive
    234
                ? (block.timestamp < order.deadlineTimestamp ? "Active" : "Expired (Active but past deadline)")
    235
                : "Inactive (Filled/Cancelled)";
    236
            if (order.isActive && block.timestamp >= order.deadlineTimestamp) {
    237
                status = "Expired (Awaiting Cancellation)";
    238
            } else if (!order.isActive) {
    239
                status = "Inactive (Filled/Cancelled)";
    240
            } else {
    241
                status = "Active";
    242
            }
    243
    
                                                    
                                                
    244
            details = string(
    245
                abi.encodePacked(
    246
                    "Order ID: ",
    247
                    order.id.toString(),
    248
                    "\n",
    249
                    "Seller: ",
    250
                    Strings.toHexString(uint160(order.seller), 20),
    251
                    "\n",
    252
                    "Selling: ",
    253
                    order.amountToSell.toString(),
    254
                    " ",
    255
                    tokenSymbol,
    256
                    "\n",
    257
                    "Asking Price: ",
    258
                    order.priceInUSDC.toString(),
    259
                    " USDC\n",
    260
                    "Deadline Timestamp: ",
    261
                    order.deadlineTimestamp.toString(),
    262
                    "\n",
    263
                    "Status: ",
    264
                    status
    265
                )
    266
            );
    267
    
                                                    
                                                
    268
            return details;
    269
        }
    270
    
                                                    
                                                
    271
        function setAllowedSellToken(address _token, bool _isAllowed) external onlyOwner {
    272
            if (_token == address(0) || _token == address(iUSDC)) revert InvalidToken(); // Cannot allow null or USDC itself
    273
            allowedSellToken[_token] = _isAllowed;
    274
    
                                                    
                                                
    275
            emit TokenAllowed(_token, _isAllowed);
    276
        }
    277
    
                                                    
                                                
    278
        function emergencyWithdrawERC20(address _tokenAddress, uint256 _amount, address _to) external onlyOwner {
    279
            if (
    280
                _tokenAddress == address(iWETH) || _tokenAddress == address(iWBTC) || _tokenAddress == address(iWSOL)
    281
                    || _tokenAddress == address(iUSDC)
    282
            ) {
    283
                revert("Cannot withdraw core order book tokens via emergency function");
    284
            }
    285
            if (_to == address(0)) {
    286
                revert InvalidAddress();
    287
            }
    288
            IERC20 token = IERC20(_tokenAddress);
    289
            token.safeTransfer(_to, _amount);
    290
    
                                                    
                                                
    291
            emit EmergencyWithdrawal(_tokenAddress, _amount, _to);
    292
        }
    293
    
                                                    
                                                
    294
        function withdrawFees(address _to) external onlyOwner {
    295
            if (totalFees == 0) {
    296
                revert InvalidAmount();
    297
            }
    298
            if (_to == address(0)) {
    299
                revert InvalidAddress();
    300
            }
    301
    
                                                    
                                                
    302
            iUSDC.safeTransfer(_to, totalFees);
    303
    
                                                    
                                                
    304
            totalFees = 0;
    305
    
                                                    
                                                
    306
            emit FeesWithdrawn(_to);
    307
        }
    308
    }
    309
    
                                                    
                                                
    0.0% test/TestOrderBook.t.sol
    Lines covered: 0 / 126 (0.0%)
    1
    // SPDX-License-Identifier: SEE LICENSE IN LICENSE
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    import {Test, console2} from "forge-std/Test.sol";
    5
    import {OrderBook} from "../src/OrderBook.sol";
    6
    import {MockUSDC} from "./mocks/MockUSDC.sol";
    7
    import {MockWBTC} from "./mocks/MockWBTC.sol";
    8
    import {MockWETH} from "./mocks/MockWETH.sol";
    9
    import {MockWSOL} from "./mocks/MockWSOL.sol";
    10
    
                                                    
                                                
    11
    contract TestOrderBook is Test {
    12
        OrderBook book;
    13
    
                                                    
                                                
    14
        MockUSDC usdc;
    15
        MockWBTC wbtc;
    16
        MockWETH weth;
    17
        MockWSOL wsol;
    18
    
                                                    
                                                
    19
        address owner;
    20
        address alice;
    21
        address bob;
    22
        address clara;
    23
        address dan;
    24
    
                                                    
                                                
    25
        uint256 mdd;
    26
    
                                                    
                                                
    27
        function setUp() public {
    28
            owner = makeAddr("protocol_owner");
    29
            alice = makeAddr("will_sell_wbtc_order");
    30
            bob = makeAddr("will_sell_weth_order");
    31
            clara = makeAddr("will_sell_wsol_order");
    32
            dan = makeAddr("will_buy_orders");
    33
    
                                                    
                                                
    34
            usdc = new MockUSDC(6);
    35
            wbtc = new MockWBTC(8);
    36
            weth = new MockWETH(18);
    37
            wsol = new MockWSOL(18);
    38
    
                                                    
                                                
    39
            vm.prank(owner);
    40
            book = new OrderBook(address(weth), address(wbtc), address(wsol), address(usdc), owner);
    41
    
                                                    
                                                
    42
            usdc.mint(dan, 200_000);
    43
            wbtc.mint(alice, 2);
    44
            weth.mint(bob, 2);
    45
            wsol.mint(clara, 2);
    46
    
                                                    
                                                
    47
            mdd = book.MAX_DEADLINE_DURATION();
    48
        }
    49
    
                                                    
                                                
    50
        function test_init() public view {
    51
            assert(usdc.balanceOf(dan) == 200_000e6);
    52
            assert(wbtc.balanceOf(alice) == 2e8);
    53
            assert(weth.balanceOf(bob) == 2e18);
    54
            assert(wsol.balanceOf(clara) == 2e18);
    55
    
                                                    
                                                
    56
            assert(mdd == 3 days);
    57
        }
    58
    
                                                    
                                                
    59
        function test_createSellOrder() public {
    60
            // alice creates sell order for wbtc
    61
            vm.startPrank(alice);
    62
            wbtc.approve(address(book), 2e8);
    63
            uint256 aliceId = book.createSellOrder(address(wbtc), 2e8, 180_000e6, 2 days);
    64
            vm.stopPrank();
    65
    
                                                    
                                                
    66
            assert(aliceId == 1);
    67
            assert(wbtc.balanceOf(alice) == 0);
    68
            assert(wbtc.balanceOf(address(book)) == 2e8);
    69
    
                                                    
                                                
    70
            // bob creates sell order for weth
    71
            vm.startPrank(bob);
    72
            weth.approve(address(book), 2e18);
    73
            uint256 bobId = book.createSellOrder(address(weth), 2e18, 5_000e6, 2 days);
    74
            vm.stopPrank();
    75
    
                                                    
                                                
    76
            assert(bobId == 2);
    77
            assert(weth.balanceOf(bob) == 0);
    78
            assert(weth.balanceOf(address(book)) == 2e18);
    79
    
                                                    
                                                
    80
            // clara creates sell order for wsol
    81
            vm.startPrank(clara);
    82
            wsol.approve(address(book), 2e18);
    83
            uint256 claraId = book.createSellOrder(address(wsol), 2e18, 300e6, 2 days);
    84
            vm.stopPrank();
    85
    
                                                    
                                                
    86
            assert(claraId == 3);
    87
            assert(wsol.balanceOf(clara) == 0);
    88
            assert(wsol.balanceOf(address(book)) == 2e18);
    89
        }
    90
    
                                                    
                                                
    91
        function test_amendSellOrder() public {
    92
            // alice creates sell order for wbtc
    93
            vm.startPrank(alice);
    94
            wbtc.approve(address(book), 2e8);
    95
            uint256 aliceId = book.createSellOrder(address(wbtc), 2e8, 180_000e6, 2 days);
    96
            vm.stopPrank();
    97
    
                                                    
                                                
    98
            // bob creates sell order for weth
    99
            vm.startPrank(bob);
    100
            weth.approve(address(book), 2e18);
    101
            uint256 bobId = book.createSellOrder(address(weth), 2e18, 5_000e6, 2 days);
    102
            vm.stopPrank();
    103
    
                                                    
                                                
    104
            // clara creates sell order for wsol
    105
            vm.startPrank(clara);
    106
            wsol.approve(address(book), 2e18);
    107
            uint256 claraId = book.createSellOrder(address(wsol), 2e18, 300e6, 2 days);
    108
            vm.stopPrank();
    109
    
                                                    
                                                
    110
            vm.warp(block.timestamp + 1 days);
    111
    
                                                    
                                                
    112
            // alice amends her wbtc sell order
    113
            vm.prank(alice);
    114
            book.amendSellOrder(aliceId, 1.75e8, 175_000e6, 0.5 days);
    115
            string memory aliceOrderDetails = book.getOrderDetailsString(aliceId);
    116
            console2.log(aliceOrderDetails);
    117
            assert(wbtc.balanceOf(alice) == 0.25e8);
    118
            assert(wbtc.balanceOf(address(book)) == 1.75e8);
    119
    
                                                    
                                                
    120
            // bob amends his weth order
    121
            vm.prank(bob);
    122
            book.amendSellOrder(bobId, 1.75e18, 4_550e6, 0.5 days);
    123
            string memory bobOrderDetails = book.getOrderDetailsString(bobId);
    124
            console2.log(bobOrderDetails);
    125
            assert(weth.balanceOf(bob) == 0.25e18);
    126
            assert(weth.balanceOf(address(book)) == 1.75e18);
    127
    
                                                    
                                                
    128
            // clara amends her wsol order
    129
            vm.prank(clara);
    130
            book.amendSellOrder(claraId, 1.75e18, 350e6, 0.5 days);
    131
            string memory claraOrderDetails = book.getOrderDetailsString(claraId);
    132
            console2.log(claraOrderDetails);
    133
            assert(wsol.balanceOf(clara) == 0.25e18);
    134
            assert(wsol.balanceOf(address(book)) == 1.75e18);
    135
        }
    136
    
                                                    
                                                
    137
        function test_cancelSellOrder() public {
    138
            // alice creates sell order for wbtc
    139
            vm.startPrank(alice);
    140
            wbtc.approve(address(book), 2e8);
    141
            uint256 aliceId = book.createSellOrder(address(wbtc), 2e8, 180_000e6, 2 days);
    142
            vm.stopPrank();
    143
    
                                                    
                                                
    144
            // bob creates sell order for weth
    145
            vm.startPrank(bob);
    146
            weth.approve(address(book), 2e18);
    147
            uint256 bobId = book.createSellOrder(address(weth), 2e18, 5_000e6, 2 days);
    148
            vm.stopPrank();
    149
    
                                                    
                                                
    150
            // clara creates sell order for wsol
    151
            vm.startPrank(clara);
    152
            wsol.approve(address(book), 2e18);
    153
            uint256 claraId = book.createSellOrder(address(wsol), 2e18, 300e6, 2 days);
    154
            vm.stopPrank();
    155
    
                                                    
                                                
    156
            // alice cancels wbtc sell order
    157
            vm.prank(alice);
    158
            book.cancelSellOrder(aliceId);
    159
    
                                                    
                                                
    160
            // bob cancels weth order
    161
            vm.prank(bob);
    162
            book.cancelSellOrder(bobId);
    163
    
                                                    
                                                
    164
            // clara cancels sell order
    165
            vm.prank(clara);
    166
            book.cancelSellOrder(claraId);
    167
        }
    168
    
                                                    
                                                
    169
        function test_buyOrder() public {
    170
            // alice creates sell order for wbtc
    171
            vm.startPrank(alice);
    172
            wbtc.approve(address(book), 2e8);
    173
            uint256 aliceId = book.createSellOrder(address(wbtc), 2e8, 180_000e6, 2 days);
    174
            vm.stopPrank();
    175
    
                                                    
                                                
    176
            assert(aliceId == 1);
    177
            assert(wbtc.balanceOf(alice) == 0);
    178
            assert(wbtc.balanceOf(address(book)) == 2e8);
    179
    
                                                    
                                                
    180
            // bob creates sell order for weth
    181
            vm.startPrank(bob);
    182
            weth.approve(address(book), 2e18);
    183
            uint256 bobId = book.createSellOrder(address(weth), 2e18, 5_000e6, 2 days);
    184
            vm.stopPrank();
    185
    
                                                    
                                                
    186
            assert(bobId == 2);
    187
            assert(weth.balanceOf(bob) == 0);
    188
            assert(weth.balanceOf(address(book)) == 2e18);
    189
    
                                                    
                                                
    190
            // clara creates sell order for wsol
    191
            vm.startPrank(clara);
    192
            wsol.approve(address(book), 2e18);
    193
            uint256 claraId = book.createSellOrder(address(wsol), 2e18, 300e6, 2 days);
    194
            vm.stopPrank();
    195
    
                                                    
                                                
    196
            vm.startPrank(dan);
    197
            usdc.approve(address(book), 200_000e6);
    198
            book.buyOrder(aliceId); // dan buys alice wbtc order
    199
            book.buyOrder(bobId); // dan buys bob weth order
    200
            book.buyOrder(claraId); // dan buys clara wsol order
    201
            vm.stopPrank();
    202
    
                                                    
                                                
    203
            assert(wbtc.balanceOf(dan) == 2e8);
    204
            assert(weth.balanceOf(dan) == 2e18);
    205
            assert(wsol.balanceOf(dan) == 2e18);
    206
    
                                                    
                                                
    207
            assert(usdc.balanceOf(alice) == 174_600e6);
    208
            assert(usdc.balanceOf(bob) == 4_850e6);
    209
            assert(usdc.balanceOf(clara) == 291e6);
    210
    
                                                    
                                                
    211
            assert(book.totalFees() == 5_559e6);
    212
    
                                                    
                                                
    213
            vm.prank(owner);
    214
            book.withdrawFees(owner);
    215
    
                                                    
                                                
    216
            assert(usdc.balanceOf(owner) == 5_559e6);
    217
        }
    218
    }
    219
    
                                                    
                                                
    98.1% test/invariant/FuzzBook.sol
    Lines covered: 52 / 53 (98.1%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.20;
    3
    
                                                    
                                                
    4
    import {OrderBook} from "../../src/OrderBook.sol";
    5
    import {MockUSDC} from "../mocks/MockUSDC.sol";
    6
    import {MockWBTC} from "../mocks/MockWBTC.sol";
    7
    import {MockWETH} from "../mocks/MockWETH.sol";
    8
    import {MockWSOL} from "../mocks/MockWSOL.sol";
    9
    import "./utils/StdCheats.sol";
    10
    import {PropertiesAsserts} from "./utils/PropertiesHelper.sol";
    11
    
                                                    
                                                
    12
    contract FuzzBook is PropertiesAsserts {
    13
        OrderBook book;
    14
    
                                                    
                                                
    15
        MockUSDC usdc;
    16
        MockWBTC wbtc;
    17
        MockWETH weth;
    18
        MockWSOL wsol;
    19
    ✓ 1
        StdCheats cheats = StdCheats(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    20
    
                                                    
                                                
    21
    ✓ 1
        address owner = address(0x1);
    22
    ✓ 1
        address alice = address(0x2);
    23
    ✓ 1
        address bob = address(0x3);
    24
    ✓ 1
        address clara = address(0x4);
    25
    ✓ 1
        address dan = address(0x5);
    26
    
                                                    
                                                
    27
        uint256 initialUSDCInBook;
    28
        uint256 initialWBTCInBook;
    29
        uint256 initialWETHInBook;
    30
        uint256 initialWSOLInBook;
    31
        uint256 max_deadline;
    32
    
                                                    
                                                
    33
        uint64 mintAmount;
    34
    
                                                    
                                                
    35
        constructor() {
    36
    ✓ 1
            usdc = new MockUSDC(6);
    37
    ✓ 1
            wbtc = new MockWBTC(8);
    38
    ✓ 1
            weth = new MockWETH(18);
    39
    ✓ 1
            wsol = new MockWSOL(18);
    40
    
                                                    
                                                
    41
    ✓ 1
            cheats.prank(owner);
    42
    ✓ 1
            book = new OrderBook(
    43
    ✓ 1
                address(weth),
    44
    ✓ 1
                address(wbtc),
    45
    ✓ 1
                address(wsol),
    46
    ✓ 1
                address(usdc),
    47
    ✓ 1
                owner
    48
            );
    49
    
                                                    
                                                
    50
    ✓ 1
            mintAmount = type(uint64).max;
    51
    
                                                    
                                                
    52
    ✓ 1
            wbtc.mint(alice, uint256(mintAmount));
    53
    ✓ 1
            weth.mint(bob, uint256(mintAmount));
    54
    ✓ 1
            wsol.mint(clara, uint256(mintAmount));
    55
    ✓ 1
            usdc.mint(dan, uint256(mintAmount));
    56
    
                                                    
                                                
    57
    ✓ 1
            cheats.prank(alice);
    58
    ✓ 1
            wbtc.approve(address(book), uint256(mintAmount));
    59
    
                                                    
                                                
    60
    ✓ 1
            cheats.prank(bob);
    61
    ✓ 1
            weth.approve(address(book), uint256(mintAmount));
    62
    
                                                    
                                                
    63
    ✓ 1
            cheats.prank(clara);
    64
    ✓ 1
            wsol.approve(address(book), uint256(mintAmount));
    65
    
                                                    
                                                
    66
    ✓ 1
            cheats.prank(dan);
    67
    ✓ 1
            usdc.approve(address(book), uint256(mintAmount));
    68
        }
    69
    
                                                    
                                                
    70
        // function level invariants
    71
        // OrderBook balance must increase by number of tokens used by sellers to create order
    72
        function createSellOrder(uint256 amount) internal {
    73
            amount = clampBetween(amount, 1, uint256(mintAmount));
    74
    
                                                    
                                                
    75
            initialWBTCInBook = wbtc.balanceOf(address(book));
    76
            initialWETHInBook = weth.balanceOf(address(book));
    77
            initialWSOLInBook = wsol.balanceOf(address(book));
    78
    
                                                    
                                                
    79
            cheats.prank(alice);
    80
            book.createSellOrder(address(wbtc), amount, 180_000e6, 2 days);
    81
    
                                                    
                                                
    82
            cheats.prank(bob);
    83
            book.createSellOrder(address(weth), amount, 9_000e6, 2 days);
    84
    
                                                    
                                                
    85
            cheats.prank(clara);
    86
            book.createSellOrder(address(wsol), amount, 400e6, 2 days);
    87
    
                                                    
                                                
    88
            uint256 finalWBTCInBook = wbtc.balanceOf(address(book));
    89
            assert((finalWBTCInBook - initialWBTCInBook) == amount);
    90
    
                                                    
                                                
    91
            uint256 finalWETHInBook = weth.balanceOf(address(book));
    92
            assert((finalWETHInBook - initialWETHInBook) == amount);
    93
    
                                                    
                                                
    94
            uint256 finalWSOLInBook = wsol.balanceOf(address(book));
    95
            assert((finalWSOLInBook - initialWSOLInBook) == amount);
    96
        }
    97
    
                                                    
                                                
    98
        function buySellOrder(uint256 sellAmount, uint256 buyAmount) public {
    99
    ✓ 50.0K
            sellAmount = clampBetween(sellAmount, 1, uint256(mintAmount));
    100
    ✓ 50.0K
            buyAmount = clampBetween(buyAmount, 1, uint256(mintAmount));
    101
    ✓ 50.0K
            cheats.prank(alice);
    102
    
                                                    
                                                
    103
    ✓ 50.0K
            initialWBTCInBook = wbtc.balanceOf(address(book));
    104
    ✓ 50.0K
            uint256 initialAliceWBTC = wbtc.balanceOf(alice);
    105
            // uint256 initialAliceUSDC = usdc.balanceOf(alice);
    106
    
                                                    
                                                
    107
    ✓ 50.0K
            cheats.prank(alice);
    108
    ✓ 50.0K
            uint256 id = book.createSellOrder(
    109
    ✓ 50.0K
                address(wbtc),
    110
    ✓ 50.0K
                sellAmount,
    111
    ✓ 50.0K
                buyAmount,
    112
    ✓ 50.0K
                2 days
    113
            );
    114
    
                                                    
                                                
    115
    ✓ 50.0K
            uint256 finalWBTCInBook = wbtc.balanceOf(address(book));
    116
    ✓ 50.0K
            uint256 finalAliceWBTC = wbtc.balanceOf(alice);
    117
    
                                                    
                                                
    118
    ✓ 50.0K
            assert((finalWBTCInBook - initialWBTCInBook) == sellAmount);
    119
    ✓ 50.0K
            assert((initialAliceWBTC - finalAliceWBTC) == sellAmount);
    120
    
                                                    
                                                
    121
    ✓ 50.0K
            uint256 initialDanUSDC = usdc.balanceOf(dan);
    122
    ✓ 50.0K
            uint256 initialDanWBTC = wbtc.balanceOf(dan);
    123
    
                                                    
                                                
    124
    ✓ 50.0K
            cheats.prank(dan);
    125
    ✓ 50.0K
            book.buyOrder(id);
    126
    
                                                    
                                                
    127
    ✓ 50.0K
            uint256 finalDanUSDC = usdc.balanceOf(dan);
    128
    ✓ 50.0K
            uint256 finalDanWBTC = wbtc.balanceOf(dan);
    129
    
                                                    
                                                
    130
    ✓ 50.0K
            assert((initialDanUSDC - finalDanUSDC) == sellAmount);
    131
            assert((finalDanWBTC-initialDanWBTC) == buyAmount);
    132
        }
    133
    }
    134
    
                                                    
                                                
    100.0% test/invariant/utils/PropertiesHelper.sol
    Lines covered: 24 / 24 (100.0%)
    1
    // SPDX-License-Identifier: AGPL-3.0-or-later
    2
    pragma solidity ^0.8.0;
    3
    
                                                    
                                                
    4
    // Gotten from https://github.com/crytic/properties/blob/main/contracts/util/PropertiesHelper.sol
    5
    
                                                    
                                                
    6
    abstract contract PropertiesAsserts {
    7
        event LogUint256(string, uint256);
    8
        event LogAddress(string, address);
    9
        event LogString(string);
    10
    
                                                    
                                                
    11
        event AssertFail(string);
    12
        event AssertEqFail(string);
    13
        event AssertNeqFail(string);
    14
        event AssertGteFail(string);
    15
        event AssertGtFail(string);
    16
        event AssertLteFail(string);
    17
        event AssertLtFail(string);
    18
    
                                                    
                                                
    19
        function assertWithMsg(bool b, string memory reason) internal {
    20
            if (!b) {
    21
                emit AssertFail(reason);
    22
                assert(false);
    23
            }
    24
        }
    25
    
                                                    
                                                
    26
        /// @notice asserts that a is equal to b. Violations are logged using reason.
    27
        function assertEq(uint256 a, uint256 b, string memory reason) internal {
    28
            if (a != b) {
    29
                string memory aStr = PropertiesLibString.toString(a);
    30
                string memory bStr = PropertiesLibString.toString(b);
    31
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "!=", bStr, ", reason: ", reason);
    32
                emit AssertEqFail(string(assertMsg));
    33
                assert(false);
    34
            }
    35
        }
    36
    
                                                    
                                                
    37
        /// @notice int256 version of assertEq
    38
        function assertEq(int256 a, int256 b, string memory reason) internal {
    39
            if (a != b) {
    40
                string memory aStr = PropertiesLibString.toString(a);
    41
                string memory bStr = PropertiesLibString.toString(b);
    42
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "!=", bStr, ", reason: ", reason);
    43
                emit AssertEqFail(string(assertMsg));
    44
                assert(false);
    45
            }
    46
        }
    47
    
                                                    
                                                
    48
        /// @notice asserts that a is not equal to b. Violations are logged using reason.
    49
        function assertNeq(uint256 a, uint256 b, string memory reason) internal {
    50
            if (a == b) {
    51
                string memory aStr = PropertiesLibString.toString(a);
    52
                string memory bStr = PropertiesLibString.toString(b);
    53
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "==", bStr, ", reason: ", reason);
    54
                emit AssertNeqFail(string(assertMsg));
    55
                assert(false);
    56
            }
    57
        }
    58
    
                                                    
                                                
    59
        /// @notice int256 version of assertNeq
    60
        function assertNeq(int256 a, int256 b, string memory reason) internal {
    61
            if (a == b) {
    62
                string memory aStr = PropertiesLibString.toString(a);
    63
                string memory bStr = PropertiesLibString.toString(b);
    64
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "==", bStr, ", reason: ", reason);
    65
                emit AssertNeqFail(string(assertMsg));
    66
                assert(false);
    67
            }
    68
        }
    69
    
                                                    
                                                
    70
        /// @notice asserts that a is greater than or equal to b. Violations are logged using reason.
    71
        function assertGte(uint256 a, uint256 b, string memory reason) internal {
    72
            if (!(a >= b)) {
    73
                string memory aStr = PropertiesLibString.toString(a);
    74
                string memory bStr = PropertiesLibString.toString(b);
    75
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "<", bStr, " failed, reason: ", reason);
    76
                emit AssertGteFail(string(assertMsg));
    77
                assert(false);
    78
            }
    79
        }
    80
    
                                                    
                                                
    81
        /// @notice int256 version of assertGte
    82
        function assertGte(int256 a, int256 b, string memory reason) internal {
    83
            if (!(a >= b)) {
    84
                string memory aStr = PropertiesLibString.toString(a);
    85
                string memory bStr = PropertiesLibString.toString(b);
    86
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "<", bStr, " failed, reason: ", reason);
    87
                emit AssertGteFail(string(assertMsg));
    88
                assert(false);
    89
            }
    90
        }
    91
    
                                                    
                                                
    92
        /// @notice asserts that a is greater than b. Violations are logged using reason.
    93
        function assertGt(uint256 a, uint256 b, string memory reason) internal {
    94
            if (!(a > b)) {
    95
                string memory aStr = PropertiesLibString.toString(a);
    96
                string memory bStr = PropertiesLibString.toString(b);
    97
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "<=", bStr, " failed, reason: ", reason);
    98
                emit AssertGtFail(string(assertMsg));
    99
                assert(false);
    100
            }
    101
        }
    102
    
                                                    
                                                
    103
        /// @notice int256 version of assertGt
    104
        function assertGt(int256 a, int256 b, string memory reason) internal {
    105
            if (!(a > b)) {
    106
                string memory aStr = PropertiesLibString.toString(a);
    107
                string memory bStr = PropertiesLibString.toString(b);
    108
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, "<=", bStr, " failed, reason: ", reason);
    109
                emit AssertGtFail(string(assertMsg));
    110
                assert(false);
    111
            }
    112
        }
    113
    
                                                    
                                                
    114
        /// @notice asserts that a is less than or equal to b. Violations are logged using reason.
    115
        function assertLte(uint256 a, uint256 b, string memory reason) internal {
    116
            if (!(a <= b)) {
    117
                string memory aStr = PropertiesLibString.toString(a);
    118
                string memory bStr = PropertiesLibString.toString(b);
    119
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, ">", bStr, " failed, reason: ", reason);
    120
                emit AssertLteFail(string(assertMsg));
    121
                assert(false);
    122
            }
    123
        }
    124
    
                                                    
                                                
    125
        /// @notice int256 version of assertLte
    126
        function assertLte(int256 a, int256 b, string memory reason) internal {
    127
            if (!(a <= b)) {
    128
                string memory aStr = PropertiesLibString.toString(a);
    129
                string memory bStr = PropertiesLibString.toString(b);
    130
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, ">", bStr, " failed, reason: ", reason);
    131
                emit AssertLteFail(string(assertMsg));
    132
                assert(false);
    133
            }
    134
        }
    135
    
                                                    
                                                
    136
        /// @notice asserts that a is less than b. Violations are logged using reason.
    137
        function assertLt(uint256 a, uint256 b, string memory reason) internal {
    138
            if (!(a < b)) {
    139
                string memory aStr = PropertiesLibString.toString(a);
    140
                string memory bStr = PropertiesLibString.toString(b);
    141
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, ">=", bStr, " failed, reason: ", reason);
    142
                emit AssertLtFail(string(assertMsg));
    143
                assert(false);
    144
            }
    145
        }
    146
    
                                                    
                                                
    147
        /// @notice int256 version of assertLt
    148
        function assertLt(int256 a, int256 b, string memory reason) internal {
    149
            if (!(a < b)) {
    150
                string memory aStr = PropertiesLibString.toString(a);
    151
                string memory bStr = PropertiesLibString.toString(b);
    152
                bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr, ">=", bStr, " failed, reason: ", reason);
    153
                emit AssertLtFail(string(assertMsg));
    154
                assert(false);
    155
            }
    156
        }
    157
    
                                                    
                                                
    158
        /// @notice Clamps value to be between low and high, both inclusive
    159
    ✓ 100.0K
        function clampBetween(uint256 value, uint256 low, uint256 high) internal returns (uint256) {
    160
    ✓ 100.0K
            if (value < low || value > high) {
    161
    ✓ 99.9K
                uint256 ans = low + (value % (high - low + 1));
    162
    ✓ 99.9K
                string memory valueStr = PropertiesLibString.toString(value);
    163
    ✓ 99.9K
                string memory ansStr = PropertiesLibString.toString(ans);
    164
    ✓ 99.9K
                bytes memory message = abi.encodePacked("Clamping value ", valueStr, " to ", ansStr);
    165
    ✓ 99.9K
                emit LogString(string(message));
    166
    ✓ 99.9K
                return ans;
    167
            }
    168
    ✓ 79
            return value;
    169
        }
    170
    
                                                    
                                                
    171
        /// @notice int256 version of clampBetween
    172
        function clampBetween(int256 value, int256 low, int256 high) internal returns (int256) {
    173
            if (value < low || value > high) {
    174
                int256 range = high - low + 1;
    175
                int256 clamped = (value - low) % (range);
    176
                if (clamped < 0) clamped += range;
    177
                int256 ans = low + clamped;
    178
                string memory valueStr = PropertiesLibString.toString(value);
    179
                string memory ansStr = PropertiesLibString.toString(ans);
    180
                bytes memory message = abi.encodePacked("Clamping value ", valueStr, " to ", ansStr);
    181
                emit LogString(string(message));
    182
                return ans;
    183
            }
    184
            return value;
    185
        }
    186
    
                                                    
                                                
    187
        /// @notice clamps a to be less than b
    188
        function clampLt(uint256 a, uint256 b) internal returns (uint256) {
    189
            if (!(a < b)) {
    190
                assertNeq(b, 0, "clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions.");
    191
                uint256 value = a % b;
    192
                string memory aStr = PropertiesLibString.toString(a);
    193
                string memory valueStr = PropertiesLibString.toString(value);
    194
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    195
                emit LogString(string(message));
    196
                return value;
    197
            }
    198
            return a;
    199
        }
    200
    
                                                    
                                                
    201
        /// @notice int256 version of clampLt
    202
        function clampLt(int256 a, int256 b) internal returns (int256) {
    203
            if (!(a < b)) {
    204
                int256 value = b - 1;
    205
                string memory aStr = PropertiesLibString.toString(a);
    206
                string memory valueStr = PropertiesLibString.toString(value);
    207
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    208
                emit LogString(string(message));
    209
                return value;
    210
            }
    211
            return a;
    212
        }
    213
    
                                                    
                                                
    214
        /// @notice clamps a to be less than or equal to b
    215
        function clampLte(uint256 a, uint256 b) internal returns (uint256) {
    216
            if (!(a <= b)) {
    217
                uint256 value = a % (b + 1);
    218
                string memory aStr = PropertiesLibString.toString(a);
    219
                string memory valueStr = PropertiesLibString.toString(value);
    220
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    221
                emit LogString(string(message));
    222
                return value;
    223
            }
    224
            return a;
    225
        }
    226
    
                                                    
                                                
    227
        /// @notice int256 version of clampLte
    228
        function clampLte(int256 a, int256 b) internal returns (int256) {
    229
            if (!(a <= b)) {
    230
                int256 value = b;
    231
                string memory aStr = PropertiesLibString.toString(a);
    232
                string memory valueStr = PropertiesLibString.toString(value);
    233
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    234
                emit LogString(string(message));
    235
                return value;
    236
            }
    237
            return a;
    238
        }
    239
    
                                                    
                                                
    240
        /// @notice clamps a to be greater than b
    241
        function clampGt(uint256 a, uint256 b) internal returns (uint256) {
    242
            if (!(a > b)) {
    243
                assertNeq(
    244
                    b,
    245
                    type(uint256).max,
    246
                    "clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions."
    247
                );
    248
                uint256 value = b + 1;
    249
                string memory aStr = PropertiesLibString.toString(a);
    250
                string memory valueStr = PropertiesLibString.toString(value);
    251
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    252
                emit LogString(string(message));
    253
                return value;
    254
            } else {
    255
                return a;
    256
            }
    257
        }
    258
    
                                                    
                                                
    259
        /// @notice int256 version of clampGt
    260
        function clampGt(int256 a, int256 b) internal returns (int256) {
    261
            if (!(a > b)) {
    262
                int256 value = b + 1;
    263
                string memory aStr = PropertiesLibString.toString(a);
    264
                string memory valueStr = PropertiesLibString.toString(value);
    265
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    266
                emit LogString(string(message));
    267
                return value;
    268
            } else {
    269
                return a;
    270
            }
    271
        }
    272
    
                                                    
                                                
    273
        /// @notice clamps a to be greater than or equal to b
    274
        function clampGte(uint256 a, uint256 b) internal returns (uint256) {
    275
            if (!(a > b)) {
    276
                uint256 value = b;
    277
                string memory aStr = PropertiesLibString.toString(a);
    278
                string memory valueStr = PropertiesLibString.toString(value);
    279
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    280
                emit LogString(string(message));
    281
                return value;
    282
            }
    283
            return a;
    284
        }
    285
    
                                                    
                                                
    286
        /// @notice int256 version of clampGte
    287
        function clampGte(int256 a, int256 b) internal returns (int256) {
    288
            if (!(a > b)) {
    289
                int256 value = b;
    290
                string memory aStr = PropertiesLibString.toString(a);
    291
                string memory valueStr = PropertiesLibString.toString(value);
    292
                bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
    293
                emit LogString(string(message));
    294
                return value;
    295
            }
    296
            return a;
    297
        }
    298
    }
    299
    
                                                    
                                                
    300
    /// @notice Efficient library for creating string representations of integers.
    301
    /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
    302
    /// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
    303
    /// @dev Name of the library is modified to prevent collisions with contract-under-test uses of LibString
    304
    ✓ 15
    library PropertiesLibString {
    305
        function toString(int256 value) internal pure returns (string memory str) {
    306
            uint256 absValue = value >= 0 ? uint256(value) : uint256(-value);
    307
            str = toString(absValue);
    308
    
                                                    
                                                
    309
            if (value < 0) {
    310
                str = string(abi.encodePacked("-", str));
    311
            }
    312
        }
    313
    
                                                    
                                                
    314
    ✓ 199.8K
        function toString(uint256 value) internal pure returns (string memory str) {
    315
            /// @solidity memory-safe-assembly
    316
            assembly {
    317
                // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
    318
                // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
    319
                // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
    320
    ✓ 199.8K
                let newFreeMemoryPointer := add(mload(0x40), 160)
    321
    
                                                    
                                                
    322
                // Update the free memory pointer to avoid overriding our string.
    323
    ✓ 199.8K
                mstore(0x40, newFreeMemoryPointer)
    324
    
                                                    
                                                
    325
                // Assign str to the end of the zone of newly allocated memory.
    326
    ✓ 199.8K
                str := sub(newFreeMemoryPointer, 32)
    327
    
                                                    
                                                
    328
                // Clean the last word of memory it may not be overwritten.
    329
    ✓ 199.8K
                mstore(str, 0)
    330
    
                                                    
                                                
    331
                // Cache the end of the memory to calculate the length later.
    332
    ✓ 199.8K
                let end := str
    333
    
                                                    
                                                
    334
                // We write the string from rightmost digit to leftmost digit.
    335
                // The following is essentially a do-while loop that also handles the zero case.
    336
                // prettier-ignore
    337
    ✓ 8.2M
                for { let temp := value } 1 {} {
    338
                    // Move the pointer 1 byte to the left.
    339
    ✓ 8.2M
                    str := sub(str, 1)
    340
    
                                                    
                                                
    341
                    // Write the character to the pointer.
    342
                    // The ASCII index of the '0' character is 48.
    343
    ✓ 8.2M
                    mstore8(str, add(48, mod(temp, 10)))
    344
    
                                                    
                                                
    345
                    // Keep dividing temp until zero.
    346
    ✓ 8.2M
                    temp := div(temp, 10)
    347
    
                                                    
                                                
    348
                    // prettier-ignore
    349
    ✓ 8.2M
                    if iszero(temp) { break }
    350
                }
    351
    
                                                    
                                                
    352
                // Compute and cache the final total length of the string.
    353
    ✓ 199.8K
                let length := sub(end, str)
    354
    
                                                    
                                                
    355
                // Move the pointer 32 bytes leftwards to make room for the length.
    356
    ✓ 199.8K
                str := sub(str, 32)
    357
    
                                                    
                                                
    358
                // Store the string's length at the start of memory allocated for our string.
    359
    ✓ 199.8K
                mstore(str, length)
    360
            }
    361
        }
    362
    
                                                    
                                                
    363
        function toString(address value) internal pure returns (string memory str) {
    364
            bytes memory s = new bytes(40);
    365
            for (uint256 i = 0; i < 20; i++) {
    366
                bytes1 b = bytes1(uint8(uint256(uint160(value)) / (2 ** (8 * (19 - i)))));
    367
                bytes1 hi = bytes1(uint8(b) / 16);
    368
                bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
    369
                s[2 * i] = char(hi);
    370
                s[2 * i + 1] = char(lo);
    371
            }
    372
            return string(s);
    373
        }
    374
    
                                                    
                                                
    375
        function char(bytes1 b) internal pure returns (bytes1 c) {
    376
            if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
    377
            else return bytes1(uint8(b) + 0x57);
    378
        }
    379
    }
    380
    
                                                    
                                                
    0.0% test/invariant/utils/StdCheats.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.5.0;
    3
    pragma experimental ABIEncoderV2;
    4
    
                                                    
                                                
    5
    interface StdCheats {
    6
        // Set block.timestamp
    7
        function warp(uint256) external;
    8
    
                                                    
                                                
    9
        // Set block.number
    10
        function roll(uint256) external;
    11
    
                                                    
                                                
    12
        // Set block.basefee
    13
        function fee(uint256) external;
    14
    
                                                    
                                                
    15
        // Set block.difficulty and block.prevrandao
    16
        function difficulty(uint256) external;
    17
    
                                                    
                                                
    18
        // Set block.chainid
    19
        function chainId(uint256) external;
    20
    
                                                    
                                                
    21
        // Sets the block.coinbase
    22
        function coinbase(address) external;
    23
    
                                                    
                                                
    24
        // Loads a storage slot from an address
    25
        function load(address account, bytes32 slot) external returns (bytes32);
    26
    
                                                    
                                                
    27
        // Stores a value to an address' storage slot
    28
        function store(address account, bytes32 slot, bytes32 value) external;
    29
    
                                                    
                                                
    30
        // Sets the *next* call's msg.sender to be the input address
    31
        function prank(address) external;
    32
    
                                                    
                                                
    33
        // Sets all subsequent call's msg.sender (until stopPrank is called) to be the input address
    34
        function startPrank(address) external;
    35
    
                                                    
                                                
    36
        // Stops a previously called startPrank
    37
        function stopPrank() external;
    38
    
                                                    
                                                
    39
        // Set msg.sender to the input address until the current call exits
    40
        function prankHere(address) external;
    41
    
                                                    
                                                
    42
        // Sets an address' balance
    43
        function deal(address who, uint256 newBalance) external;
    44
    
                                                    
                                                
    45
        // Sets an address' code
    46
        function etch(address who, bytes calldata code) external;
    47
    
                                                    
                                                
    48
        // Signs data
    49
        function sign(uint256 privateKey, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
    50
    
                                                    
                                                
    51
        // Computes address for a given private key
    52
        function addr(uint256 privateKey) external returns (address);
    53
    
                                                    
                                                
    54
        // Gets the nonce of an account
    55
        function getNonce(address account) external returns (uint64);
    56
    
                                                    
                                                
    57
        // Sets the nonce of an account
    58
        // The new nonce must be higher than the current nonce of the account
    59
        function setNonce(address account, uint64 nonce) external;
    60
    
                                                    
                                                
    61
        // Performs a foreign function call via terminal
    62
        function ffi(string[] calldata) external returns (bytes memory);
    63
    
                                                    
                                                
    64
        // Take a snapshot of the current state of the EVM
    65
        function snapshot() external returns (uint256);
    66
    
                                                    
                                                
    67
        // Revert state back to a snapshot
    68
        function revertTo(uint256) external returns (bool);
    69
    
                                                    
                                                
    70
        // Convert Solidity types to strings
    71
        function toString(address) external returns (string memory);
    72
    
                                                    
                                                
    73
        function toString(bytes calldata) external returns (string memory);
    74
    
                                                    
                                                
    75
        function toString(bytes32) external returns (string memory);
    76
    
                                                    
                                                
    77
        function toString(bool) external returns (string memory);
    78
    
                                                    
                                                
    79
        function toString(uint256) external returns (string memory);
    80
    
                                                    
                                                
    81
        function toString(int256) external returns (string memory);
    82
    
                                                    
                                                
    83
        // Convert strings into Solidity types
    84
        function parseBytes(string calldata) external returns (bytes memory);
    85
    
                                                    
                                                
    86
        function parseBytes32(string calldata) external returns (bytes32);
    87
    
                                                    
                                                
    88
        function parseAddress(string calldata) external returns (address);
    89
    
                                                    
                                                
    90
        function parseUint(string calldata) external returns (uint256);
    91
    
                                                    
                                                
    92
        function parseInt(string calldata) external returns (int256);
    93
    
                                                    
                                                
    94
        function parseBool(string calldata) external returns (bool);
    95
    }
    96
    
                                                    
                                                
    60.0% test/mocks/MockUSDC.sol
    Lines covered: 3 / 5 (60.0%)
    1
    // SPDX-License-Identifier: SEE LICENSE IN LICENSE
    2
    pragma solidity 0.8.26;
    3
    
                                                    
                                                
    4
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    5
    
                                                    
                                                
    6
    contract MockUSDC is ERC20 {
    7
        uint8 tokenDecimals;
    8
    
                                                    
                                                
    9
        constructor(uint8 _tokenDecimals) ERC20("MockUSDC", "mUSDC") {
    10
    ✓ 1
            tokenDecimals = _tokenDecimals;
    11
        }
    12
    
                                                    
                                                
    13
        function decimals() public view override returns (uint8) {
    14
            return tokenDecimals;
    15
        }
    16
    
                                                    
                                                
    17
        function mint(address to, uint256 value) public {
    18
    ✓ 1
            uint256 updateDecimals = uint256(tokenDecimals);
    19
    ✓ 1
            _mint(to, (value * 10 ** updateDecimals));
    20
        }
    21
    }
    22
    
                                                    
                                                
    60.0% test/mocks/MockWBTC.sol
    Lines covered: 3 / 5 (60.0%)
    1
    // SPDX-License-Identifier: SEE LICENSE IN LICENSE
    2
    pragma solidity 0.8.26;
    3
    
                                                    
                                                
    4
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    5
    
                                                    
                                                
    6
    contract MockWBTC is ERC20 {
    7
        uint8 tokenDecimals;
    8
    
                                                    
                                                
    9
        constructor(uint8 _tokenDecimals) ERC20("MockWBTC", "mWBTC") {
    10
    ✓ 1
            tokenDecimals = _tokenDecimals;
    11
        }
    12
    
                                                    
                                                
    13
        function decimals() public view override returns (uint8) {
    14
            return tokenDecimals;
    15
        }
    16
    
                                                    
                                                
    17
        function mint(address to, uint256 value) public {
    18
    ✓ 1
            uint256 updateDecimals = uint256(tokenDecimals);
    19
    ✓ 1
            _mint(to, (value * 10 ** updateDecimals));
    20
        }
    21
    }
    22
    
                                                    
                                                
    60.0% test/mocks/MockWETH.sol
    Lines covered: 3 / 5 (60.0%)
    1
    // SPDX-License-Identifier: SEE LICENSE IN LICENSE
    2
    pragma solidity 0.8.26;
    3
    
                                                    
                                                
    4
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    5
    
                                                    
                                                
    6
    contract MockWETH is ERC20 {
    7
        uint8 tokenDecimals;
    8
    
                                                    
                                                
    9
        constructor(uint8 _tokenDecimals) ERC20("MockWETH", "mWETH") {
    10
    ✓ 1
            tokenDecimals = _tokenDecimals;
    11
        }
    12
    
                                                    
                                                
    13
        function decimals() public view override returns (uint8) {
    14
            return tokenDecimals;
    15
        }
    16
    
                                                    
                                                
    17
        function mint(address to, uint256 value) public {
    18
    ✓ 1
            uint256 updateDecimals = uint256(tokenDecimals);
    19
    ✓ 1
            _mint(to, (value * 10 ** updateDecimals));
    20
        }
    21
    }
    22
    
                                                    
                                                
    60.0% test/mocks/MockWSOL.sol
    Lines covered: 3 / 5 (60.0%)
    1
    // SPDX-License-Identifier: SEE LICENSE IN LICENSE
    2
    pragma solidity 0.8.26;
    3
    
                                                    
                                                
    4
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    5
    
                                                    
                                                
    6
    contract MockWSOL is ERC20 {
    7
        uint8 tokenDecimals;
    8
    
                                                    
                                                
    9
        constructor(uint8 _tokenDecimals) ERC20("MockWSOL", "mWSOL") {
    10
    ✓ 1
            tokenDecimals = _tokenDecimals;
    11
        }
    12
    
                                                    
                                                
    13
        function decimals() public view override returns (uint8) {
    14
            return tokenDecimals;
    15
        }
    16
    
                                                    
                                                
    17
        function mint(address to, uint256 value) public {
    18
    ✓ 1
            uint256 updateDecimals = uint256(tokenDecimals);
    19
    ✓ 1
            _mint(to, (value * 10 ** updateDecimals));
    20
        }
    21
    }
    22